Allow slice to overflow on both starting and ending positions

Prior to this patch, ending positions could overflow but
not starting ones.

Author: josevalim

lib/elixir/lib/enum.ex

@@ -465,7 +465,7 @@ defmodule Enum do
   """
   @spec at(t, index, default) :: element | default
   def at(enumerable, index, default \\ nil) when is_integer(index) do
-    case slice_any(enumerable, index, 1, 1) do
+    case slice_forward(enumerable, index, 1, 1) do
       [value] -> value
       [] -> default
     end
@@ -1034,7 +1034,7 @@ defmodule Enum do
   """
   @spec fetch(t, index) :: {:ok, element} | :error
   def fetch(enumerable, index) when is_integer(index) do
-    case slice_any(enumerable, index, 1, 1) do
+    case slice_forward(enumerable, index, 1, 1) do
       [value] -> {:ok, value}
       [] -> :error
     end
@@ -1060,7 +1060,7 @@ defmodule Enum do
   """
   @spec fetch!(t, index) :: element
   def fetch!(enumerable, index) when is_integer(index) do
-    case slice_any(enumerable, index, 1, 1) do
+    case slice_forward(enumerable, index, 1, 1) do
       [value] -> value
       [] -> raise Enum.OutOfBoundsError
     end
@@ -2657,14 +2657,13 @@ defmodule Enum do
   def slide(enumerable, first..last, insertion_index)
       when first < 0 or last < 0 or insertion_index < 0 do
     count = Enum.count(enumerable)
-    normalized_first = if first >= 0, do: first, else: first + count
+    normalized_first = if first >= 0, do: first, else: Kernel.max(first + count, 0)
     normalized_last = if last >= 0, do: last, else: last + count
 
     normalized_insertion_index =
       if insertion_index >= 0, do: insertion_index, else: insertion_index + count
 
-    if normalized_first >= 0 and normalized_first < count and
-         normalized_first != normalized_insertion_index do
+    if normalized_first < count and normalized_first != normalized_insertion_index do
       normalized_range = normalized_first..normalized_last//1
       slide(enumerable, normalized_range, normalized_insertion_index)
     else
@@ -2678,7 +2677,8 @@ defmodule Enum do
 
   def slide(_, first..last, insertion_index)
       when insertion_index > first and insertion_index <= last do
-    raise "Insertion index for slide must be outside the range being moved " <>
+    raise ArgumentError,
+          "insertion index for slide must be outside the range being moved " <>
             "(tried to insert #{first}..#{last} at #{insertion_index})"
   end
 
@@ -2876,7 +2876,9 @@ defmodule Enum do
       iex> Enum.slice([1, 2, 3, 4, 5], 0..-1//2)
       [1, 3, 5]
 
-  If values are out of bounds, it returns an empty list:
+  If the first position is after the end of the enumerable
+  or after the last position of the range, it returns an
+  empty list:
 
       iex> Enum.slice([1, 2, 3, 4, 5], 6..10)
       []
@@ -2924,16 +2926,16 @@ defmodule Enum do
 
   defp slice_range(enumerable, first, last, step)
        when last >= first and last >= 0 and first >= 0 do
-    slice_any(enumerable, first, last - first + 1, step)
+    slice_forward(enumerable, first, last - first + 1, step)
   end
 
   defp slice_range(enumerable, first, last, step) do
     {count, fun} = slice_count_and_fun(enumerable, step)
-    first = if first >= 0, do: first, else: first + count
+    first = if first >= 0, do: first, else: Kernel.max(first + count, 0)
     last = if last >= 0, do: last, else: last + count
     amount = last - first + 1
 
-    if first >= 0 and first < count and amount > 0 do
+    if first < count and amount > 0 do
       amount = Kernel.min(amount, count - first)
       amount = if step == 1, do: amount, else: div(amount - 1, step) + 1
       fun.(first, amount, step)
@@ -2971,22 +2973,33 @@ defmodule Enum do
       # using a negative start index
       iex> Enum.slice(1..10, -6, 3)
       [5, 6, 7]
+      iex> Enum.slice(1..10, -11, 5)
+      [1, 2, 3, 4, 5]
 
-      # out of bound start index (positive)
+      # out of bound start index
       iex> Enum.slice(1..10, 10, 5)
       []
 
-      # out of bound start index (negative)
-      iex> Enum.slice(1..10, -11, 5)
-      []
-
   """
   @spec slice(t, index, non_neg_integer) :: list
   def slice(_enumerable, start_index, 0) when is_integer(start_index), do: []
 
+  def slice(enumerable, start_index, amount)
+      when is_integer(start_index) and start_index < 0 and is_integer(amount) and amount >= 0 do
+    {count, fun} = slice_count_and_fun(enumerable, 1)
+    start_index = Kernel.max(count + start_index, 0)
+    amount = Kernel.min(amount, count - start_index)
+
+    if amount > 0 do
+      fun.(start_index, amount, 1)
+    else
+      []
+    end
+  end
+
   def slice(enumerable, start_index, amount)
       when is_integer(start_index) and is_integer(amount) and amount >= 0 do
-    slice_any(enumerable, start_index, amount, 1)
+    slice_forward(enumerable, start_index, amount, 1)
   end
 
   @doc """
@@ -4308,7 +4321,7 @@ defmodule Enum do
 
   ## slice
 
-  defp slice_any(enumerable, start, amount, step) when start < 0 do
+  defp slice_forward(enumerable, start, amount, step) when start < 0 do
     {count, fun} = slice_count_and_fun(enumerable, step)
     start = count + start
 
@@ -4321,11 +4334,11 @@ defmodule Enum do
     end
   end
 
-  defp slice_any(list, start, amount, step) when is_list(list) do
+  defp slice_forward(list, start, amount, step) when is_list(list) do
     slice_list(list, start, amount, step)
   end
 
-  defp slice_any(enumerable, start, amount, step) do
+  defp slice_forward(enumerable, start, amount, step) do
     case Enumerable.slice(enumerable) do
       {:ok, count, _} when start >= count ->
         []

lib/elixir/lib/kernel.ex

@@ -4509,6 +4509,14 @@ defmodule Kernel do
       iex> binary_slice("elixir", 0, 10)
       "elixir"
 
+  If `start` is negative, it is normalized against the binary
+  size and clamped to 0:
+
+      iex> binary_slice("elixir", -3, 10)
+      "xir"
+      iex> binary_slice("elixir", -10, 10)
+      "elixir"
+
   If the `size` is zero, an empty binary is returned:
 
       iex> binary_slice("elixir", 1, 0)
@@ -4517,17 +4525,15 @@ defmodule Kernel do
   If `start` is greater than or equal to the binary size,
   an empty binary is returned:
 
-      iex> binary_slice("elixir", 3, 10)
-      "xir"
       iex> binary_slice("elixir", 10, 10)
       ""
 
   """
   @doc since: "1.14.0"
   def binary_slice(binary, start, size)
-      when is_binary(binary) and is_integer(start) and is_integer(size) and
-             start >= 0 and size >= 0 do
+      when is_binary(binary) and is_integer(start) and is_integer(size) and size >= 0 do
     total = byte_size(binary)
+    start = if start < 0, do: max(total + start, 0), else: start
 
     case start < total do
       true -> :erlang.binary_part(binary, start, min(size, total - start))
@@ -4562,6 +4568,8 @@ defmodule Kernel do
       "ixir"
       iex> binary_slice("elixir", -4..6)
       "ixir"
+      iex> binary_slice("elixir", -10..10)
+      "elixir"
 
   For ranges where `start > stop`, you need to explicitly
   mark them as increasing:
@@ -4583,7 +4591,8 @@ defmodule Kernel do
       iex> binary_slice("elixir", 0..-1//2)
       "eii"
 
-  If values are out of bounds, it returns an empty binary:
+  If the first position is after the string ends or after
+  the last position of the range, it returns an empty string:
 
       iex> binary_slice("elixir", 10..3//1)
       ""
@@ -4600,7 +4609,7 @@ defmodule Kernel do
 
     first =
       case first < 0 do
-        true -> first + total
+        true -> max(first + total, 0)
         false -> first
       end
 
@@ -4610,7 +4619,7 @@ defmodule Kernel do
         false -> last
       end
 
-    case first >= 0 and first < total do
+    case first < total do
       true ->
         part = binary_part(binary, first, min(total - first, last - first + 1))
 

lib/elixir/lib/string.ex

@@ -2086,19 +2086,19 @@ defmodule String do
       iex> String.slice("elixir", 10, 3)
       ""
 
+  If the start position is negative, it is normalized
+  against the string length and clamped to 0:
+
       iex> String.slice("elixir", -4, 4)
       "ixir"
 
       iex> String.slice("elixir", -10, 3)
-      ""
+      "eli"
 
-      iex> String.slice("a", 0, 1500)
-      "a"
+  If start is more than the string length, an empty
+  string is returned:
 
-      iex> String.slice("a", 1, 1500)
-      ""
-
-      iex> String.slice("a", 2, 1500)
+      iex> String.slice("elixir", 10, 1500)
       ""
 
   """
@@ -2117,12 +2117,8 @@ defmodule String do
   def slice(string, start, length)
       when is_binary(string) and is_integer(start) and is_integer(length) and start < 0 and
              length >= 0 do
-    start = length(string) + start
-
-    case start >= 0 do
-      true -> do_slice(string, start, length)
-      false -> ""
-    end
+    start = max(length(string) + start, 0)
+    do_slice(string, start, length)
   end
 
   defp do_slice(string, start, length) do
@@ -2160,6 +2156,8 @@ defmodule String do
       "ixir"
       iex> String.slice("elixir", -4..6)
       "ixir"
+      iex> String.slice("elixir", -100..100)
+      "elixir"
 
   For ranges where `start > stop`, you need to explicitly
   mark them as increasing:
@@ -2181,12 +2179,11 @@ defmodule String do
       iex> String.slice("elixir", 0..-1//2)
       "eii"
 
-  If values are out of bounds, it returns an empty string:
+  If the first position is after the string ends or after
+  the last position of the range, it returns an empty string:
 
       iex> String.slice("elixir", 10..3)
       ""
-      iex> String.slice("elixir", -10..-7)
-      ""
       iex> String.slice("a", 1..1500)
       ""
 
@@ -2250,10 +2247,10 @@ defmodule String do
 
   defp slice_range_negative(string, first, last) do
     {reversed_bytes, length} = acc_bytes(string, [], 0)
-    first = add_if_negative(first, length)
+    first = add_if_negative(first, length) |> max(0)
     last = add_if_negative(last, length)
 
-    if first < 0 or first > last or first > length do
+    if first > last or first > length do
       ""
     else
       last = min(last + 1, length)

lib/elixir/test/elixir/calendar/date_range_test.exs

@@ -72,7 +72,9 @@ defmodule Date.RangeTest do
     end
 
     test "for empty range" do
+      assert Enum.slice(@empty_range, 1, 3) == []
       assert Enum.slice(@empty_range, 3, 3) == []
+      assert Enum.slice(@empty_range, -1, 3) == []
       assert Enum.slice(@empty_range, -3, 3) == []
     end
   end