Inspect.Algebra.surround_many/6 now expects Inspect.Opts

Author: José Valim

CHANGELOG.md

@@ -22,6 +22,7 @@
 
 * Deprecations
   * [IEx] IEx color configuration expects a list of atoms instead of a string with colors separated by comma
+  * [Inspect] `Inspect.Algebra.surround_many/6` now expects Inspect.Opts instead of an integer limit
   * [Inspect] `Inspect.Algebra.pretty/2` is deprecated in favor of `Inspect.Algebra.format/2` that instead returns iodata. This function was used only by documentation examples and it is unlikely to affect actual code
   * [IO] `IO.ANSI.terminal?` is deprecated in favor of `IO.ANSI.enabled?`
   * [IO] `IO.ANSI.escape/2` and `IO.ANSI.escape_fragment/2` is deprecated in favor of `IO.ANSI.format/2` and `IO.ANSI.format_fragment/2`

lib/elixir/lib/inspect.ex

@@ -297,9 +297,9 @@ defimpl Inspect, for: List do
       lists == :as_char_lists or (lists == :infer and printable?(thing)) ->
         << ?', Inspect.BitString.escape(IO.chardata_to_string(thing), ?') :: binary, ?' >>
       keyword?(thing) ->
-        surround_many("[", thing, "]", opts.limit, &keyword(&1, opts))
+        surround_many("[", thing, "]", opts, &keyword/2)
       true ->
-        surround_many("[", thing, "]", opts.limit, &to_doc(&1, opts))
+        surround_many("[", thing, "]", opts, &to_doc/2)
     end
   end
 
@@ -346,7 +346,7 @@ defimpl Inspect, for: Tuple do
   def inspect({}, _opts), do: "{}"
 
   def inspect(tuple, opts) do
-    surround_many("{", Tuple.to_list(tuple), "}", opts.limit, &to_doc(&1, opts))
+    surround_many("{", Tuple.to_list(tuple), "}", opts, &to_doc/2)
   end
 end
 
@@ -357,14 +357,14 @@ defimpl Inspect, for: Map do
 
   def inspect(map, name, opts) do
     map = :maps.to_list(map)
-    surround_many("%" <> name <> "{", map, "}", opts.limit, traverse_fun(map, opts))
+    surround_many("%" <> name <> "{", map, "}", opts, traverse_fun(map))
   end
 
-  defp traverse_fun(list, opts) do
+  defp traverse_fun(list) do
     if Inspect.List.keyword?(list) do
-      &Inspect.List.keyword(&1, opts)
+      &Inspect.List.keyword/2
     else
-      &to_map(&1, opts)
+      &to_map/2
     end
   end
 

lib/elixir/lib/inspect/algebra.ex

@@ -406,52 +406,95 @@ defmodule Inspect.Algebra do
   end
 
   @doc ~S"""
-  Maps and glues a collection of items together using the given separator
-  and surrounds them. A limit can be passed which, once reached, stops
-  gluing and outputs "..." instead.
+  Maps and glues a collection of items.
+
+  It uses the given left and right as surrounding and a separator for
+  each item. A limit can be passed which, once reached, stops gluing
+  and outputs "..." instead.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]", :infinity, &Integer.to_string(&1))
+      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]",
+      ...>         %Inspect.Opts{limit: :infinity}, fn i, _opts -> to_string(i) end)
       iex> Inspect.Algebra.format(doc, 5) |> IO.iodata_to_binary
       "[1,\n 2,\n 3,\n 4,\n 5]"
 
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]", 3, &Integer.to_string(&1))
+      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]",
+      ...>         %Inspect.Opts{limit: 3}, fn i, _opts -> to_string(i) end)
       iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary
       "[1, 2, 3, ...]"
 
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]", 3, &Integer.to_string(&1), "!")
+      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]",
+      ...>         %Inspect.Opts{limit: 3}, fn i, _opts -> to_string(i) end, "!")
       iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary
       "[1! 2! 3! ...]"
 
   """
   @spec surround_many(binary, [any], binary, integer | :infinity, (term -> t), binary) :: t
-  def surround_many(left, docs, right, limit, fun, separator \\ @surround_separator)
+  def surround_many(left, docs, right, opts, fun, separator \\ @surround_separator) do
+    if is_integer(opts) do
+      IO.write :stderr, "Inspect.Algebra.surround_many/6 with an integer limit is deprecated, " <>
+                        "please pass Inspect.Opts instead\n#{Exception.format_stacktrace}" 
+      old_surround_many(left, docs, right, opts, fun, separator)
+    else
+      do_surround_many(left, docs, right, opts.limit, opts, fun, separator)
+    end
+  end
+
+  def do_surround_many(left, [], right, _, _opts, _fun, _) do
+    concat(left, right)
+  end
+
+  def do_surround_many(left, docs, right, limit, _opts, fun, sep) do
+    surround(left, do_surround_many(docs, limit, _opts, fun, sep), right)
+  end
+
+  defp do_surround_many(_, 0, _opts, _fun, _sep) do
+    "..."
+  end
+
+  defp do_surround_many([h], _limit, opts, fun, _sep) do
+    fun.(h, opts)
+  end
+
+  defp do_surround_many([h|t], limit, opts, fun, sep) when is_list(t) do
+    glue(
+      concat(fun.(h, opts), sep),
+      do_surround_many(t, decrement(limit), opts, fun, sep)
+    )
+  end
+
+  defp do_surround_many([h|t], _limit, opts, fun, _sep) do
+    glue(
+      concat(fun.(h, opts), @tail_separator),
+      fun.(t, opts)
+    )
+  end
 
-  def surround_many(left, [], right, _, _fun, _) do
+  def old_surround_many(left, [], right, _, _fun, _) do
     concat(left, right)
   end
 
-  def surround_many(left, docs, right, limit, fun, sep) do
-    surround(left, surround_many(docs, limit, fun, sep), right)
+  def old_surround_many(left, docs, right, limit, fun, sep) do
+    surround(left, old_surround_many(docs, limit, fun, sep), right)
   end
 
-  defp surround_many(_, 0, _fun, _sep) do
+  defp old_surround_many(_, 0, _fun, _sep) do
     "..."
   end
 
-  defp surround_many([h], _limit, fun, _sep) do
+  defp old_surround_many([h], _limit, fun, _sep) do
     fun.(h)
   end
 
-  defp surround_many([h|t], limit, fun, sep) when is_list(t) do
+  defp old_surround_many([h|t], limit, fun, sep) when is_list(t) do
     glue(
       concat(fun.(h), sep),
-      surround_many(t, decrement(limit), fun, sep)
+      old_surround_many(t, decrement(limit), fun, sep)
     )
   end
 
-  defp surround_many([h|t], _limit, fun, _sep) do
+  defp old_surround_many([h|t], _limit, fun, _sep) do
     glue(
       concat(fun.(h), @tail_separator),
       fun.(t)