Reduce allocation on Inspect.Algebra by using cons cells

Author: josevalim

lib/elixir/lib/code/formatter.ex

@@ -2500,16 +2500,16 @@ defmodule Code.Formatter do
 
   # Relying on the inner document is brittle and error prone.
   # It would be best if we had a mechanism to apply this.
-  defp concat_to_last_group({:doc_cons, left, right}, concat) do
-    {:doc_cons, left, concat_to_last_group(right, concat)}
+  defp concat_to_last_group([left | right], concat) do
+    [left | concat_to_last_group(right, concat)]
   end
 
   defp concat_to_last_group({:doc_group, group, mode}, concat) do
-    {:doc_group, {:doc_cons, group, concat}, mode}
+    {:doc_group, concat(group, concat), mode}
   end
 
   defp concat_to_last_group(other, concat) do
-    {:doc_cons, other, concat}
+    concat(other, concat)
   end
 
   defp ungroup_if_group({:doc_group, group, _mode}), do: group

lib/elixir/lib/inspect.ex

@@ -326,7 +326,7 @@ defimpl Inspect, for: BitString do
   end
 
   defp each_bit(<<>>, _counter, _opts) do
-    :doc_nil
+    Inspect.Algebra.empty()
   end
 
   defp each_bit(<<h::8>>, _counter, opts) do

lib/elixir/lib/inspect/algebra.ex

@@ -181,8 +181,8 @@ defmodule Inspect.Algebra do
   additions, like support for binary nodes and a break mode that
   maximises use of horizontal space.
 
-      iex> Inspect.Algebra.empty()
-      :doc_nil
+      iex> Inspect.Algebra.line()
+      :doc_line
 
       iex> "foo"
       "foo"
@@ -251,19 +251,34 @@ defmodule Inspect.Algebra do
 
   @type t ::
           binary
-          | :doc_line
-          | :doc_nil
+          | doc_nil
+          | doc_cons
+          | doc_line
           | doc_break
           | doc_collapse
           | doc_color
-          | doc_cons
           | doc_fits
           | doc_force
           | doc_group
           | doc_nest
           | doc_string
           | doc_limit
 
+  @typep doc_nil :: []
+  defmacrop doc_nil do
+    []
+  end
+
+  @typep doc_line :: :doc_line
+  defmacrop doc_line do
+    :doc_line
+  end
+
+  @typep doc_cons :: nonempty_improper_list(t, t)
+  defmacrop doc_cons(left, right) do
+    quote do: [unquote(left) | unquote(right)]
+  end
+
   @typep doc_string :: {:doc_string, t, non_neg_integer}
   defmacrop doc_string(string, length) do
     quote do: {:doc_string, unquote(string), unquote(length)}
@@ -274,11 +289,6 @@ defmodule Inspect.Algebra do
     quote do: {:doc_limit, unquote(doc), unquote(limit)}
   end
 
-  @typep doc_cons :: {:doc_cons, t, t}
-  defmacrop doc_cons(left, right) do
-    quote do: {:doc_cons, unquote(left), unquote(right)}
-  end
-
   @typep doc_nest :: {:doc_nest, t, :cursor | :reset | non_neg_integer, :always | :break}
   defmacrop doc_nest(doc, indent, always_or_break) do
     quote do: {:doc_nest, unquote(doc), unquote(indent), unquote(always_or_break)}
@@ -328,7 +338,7 @@ defmodule Inspect.Algebra do
   ]
 
   defguard is_doc(doc)
-           when is_binary(doc) or doc in [:doc_nil, :doc_line] or
+           when is_list(doc) or is_binary(doc) or doc == doc_line() or
                   (is_tuple(doc) and elem(doc, 0) in @docs)
 
   defguardp is_width(width) when width == :infinity or (is_integer(width) and width >= 0)
@@ -508,8 +518,8 @@ defmodule Inspect.Algebra do
 
         group =
           case flex? do
-            true -> group(concat(concat(left, nest(docs, 1)), right))
-            false -> group(glue(nest(glue(left, "", docs), 2), "", right))
+            true -> doc_group(concat(concat(left, nest(docs, 1)), right), :normal)
+            false -> doc_group(glue(nest(glue(left, "", docs), 2), "", right), :normal)
           end
 
         {group, inspect_opts}
@@ -550,21 +560,21 @@ defmodule Inspect.Algebra do
 
     case fun.(term, changed_opts) do
       {doc, %Inspect.Opts{} = opts} -> {doc, opts}
-      :doc_nil -> {:doc_nil, opts}
+      doc_nil() -> {doc_nil(), opts}
       doc -> {doc, changed_opts}
     end
   end
 
-  defp join(:doc_nil, :doc_nil, _, _), do: :doc_nil
-  defp join(left, :doc_nil, _, _), do: left
-  defp join(:doc_nil, right, _, _), do: right
+  defp join(doc_nil(), doc_nil(), _, _), do: doc_nil()
+  defp join(left, doc_nil(), _, _), do: left
+  defp join(doc_nil(), right, _, _), do: right
   defp join(left, right, true, sep), do: flex_glue(concat(left, sep), right)
   defp join(left, right, false, sep), do: glue(concat(left, sep), right)
 
   defp simple?(doc_cons(left, right)), do: simple?(left) and simple?(right)
   defp simple?(doc_color(doc, _)), do: simple?(doc)
   defp simple?(doc_string(_, _)), do: true
-  defp simple?(:doc_nil), do: true
+  defp simple?(doc_nil()), do: true
   defp simple?(other), do: is_binary(other)
 
   @doc false
@@ -615,17 +625,29 @@ defmodule Inspect.Algebra do
 
   # Algebra API
 
+  @compile {:inline,
+            empty: 0,
+            concat: 2,
+            break: 0,
+            break: 1,
+            glue: 2,
+            glue: 3,
+            flex_break: 0,
+            flex_break: 1,
+            flex_glue: 2,
+            flex_glue: 3}
+
   @doc """
   Returns a document entity used to represent nothingness.
 
   ## Examples
 
       iex> Inspect.Algebra.empty()
-      :doc_nil
+      []
 
   """
-  @spec empty() :: :doc_nil
-  def empty, do: :doc_nil
+  @spec empty() :: doc_nil()
+  def empty, do: doc_nil()
 
   @doc ~S"""
   Creates a document represented by string.
@@ -1023,7 +1045,7 @@ defmodule Inspect.Algebra do
   """
   @doc since: "1.6.0"
   @spec line() :: t
-  def line(), do: :doc_line
+  def line(), do: doc_line()
 
   @doc ~S"""
   Inserts a mandatory linebreak between two documents.
@@ -1163,20 +1185,20 @@ defmodule Inspect.Algebra do
     do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])
 
   defp fits?(_, _, _, [{_, :break_no_flat, doc_break(_, _)} | _]), do: true
-  defp fits?(_, _, _, [{_, :break_no_flat, :doc_line} | _]), do: true
+  defp fits?(_, _, _, [{_, :break_no_flat, doc_line()} | _]), do: true
 
   ## Breaks
 
   defp fits?(_, _, _, [{_, :break, doc_break(_, _)} | _]), do: true
-  defp fits?(_, _, _, [{_, :break, :doc_line} | _]), do: true
+  defp fits?(_, _, _, [{_, :break, doc_line()} | _]), do: true
 
   defp fits?(w, k, b?, [{i, :break, doc_group(x, _)} | t]),
     do: fits?(w, k, b?, [{i, :flat, x} | {:tail, b?, t}])
 
   ## Catch all
 
-  defp fits?(w, _, _, [{i, _, :doc_line} | t]), do: fits?(w, i, false, t)
-  defp fits?(w, k, b?, [{_, _, :doc_nil} | t]), do: fits?(w, k, b?, t)
+  defp fits?(w, _, _, [{i, _, doc_line()} | t]), do: fits?(w, i, false, t)
+  defp fits?(w, k, b?, [{_, _, doc_nil()} | t]), do: fits?(w, k, b?, t)
   defp fits?(w, _, b?, [{i, _, doc_collapse(_)} | t]), do: fits?(w, i, b?, t)
   defp fits?(w, k, b?, [{i, m, doc_color(x, _)} | t]), do: fits?(w, k, b?, [{i, m, x} | t])
   defp fits?(w, k, b?, [{_, _, doc_string(_, l)} | t]), do: fits?(w, k + l, b?, t)
@@ -1206,8 +1228,8 @@ defmodule Inspect.Algebra do
           [{integer, mode, t} | :group_over]
         ) :: [binary]
   defp format(_, _, []), do: []
-  defp format(w, k, [{_, _, :doc_nil} | t]), do: format(w, k, t)
-  defp format(w, _, [{i, _, :doc_line} | t]), do: [indent(i) | format(w, i, t)]
+  defp format(w, k, [{_, _, doc_nil()} | t]), do: format(w, k, t)
+  defp format(w, _, [{i, _, doc_line()} | t]), do: [indent(i) | format(w, i, t)]
   defp format(w, k, [{i, m, doc_cons(x, y)} | t]), do: format(w, k, [{i, m, x}, {i, m, y} | t])
   defp format(w, k, [{i, m, doc_color(x, c)} | t]), do: [c | format(w, k, [{i, m, x} | t])]
   defp format(w, k, [{_, _, doc_string(s, l)} | t]), do: [s | format(w, k + l, t)]

lib/elixir/test/elixir/inspect/algebra_test.exs

@@ -40,7 +40,7 @@ defmodule Inspect.AlgebraTest do
 
   test "empty doc" do
     # Consistent with definitions
-    assert empty() == :doc_nil
+    assert empty() == []
 
     # Consistent formatting
     assert render(empty(), 80) == ""
@@ -74,7 +74,7 @@ defmodule Inspect.AlgebraTest do
 
   test "glue doc" do
     # Consistent with definitions
-    assert glue("a", "->", "b") == {:doc_cons, "a", {:doc_cons, {:doc_break, "->", :strict}, "b"}}
+    assert glue("a", "->", "b") == ["a", {:doc_break, "->", :strict} | "b"]
     assert glue("a", "b") == glue("a", " ", "b")
 
     # Wrong argument type
@@ -84,7 +84,7 @@ defmodule Inspect.AlgebraTest do
   test "flex glue doc" do
     # Consistent with definitions
     assert flex_glue("a", "->", "b") ==
-             {:doc_cons, "a", {:doc_cons, {:doc_break, "->", :flex}, "b"}}
+             ["a", {:doc_break, "->", :flex} | "b"]
 
     assert flex_glue("a", "b") == flex_glue("a", " ", "b")
 
@@ -107,13 +107,13 @@ defmodule Inspect.AlgebraTest do
 
   test "space doc" do
     # Consistent with definitions
-    assert space("a", "b") == {:doc_cons, "a", {:doc_cons, " ", "b"}}
+    assert space("a", "b") == ["a", " " | "b"]
   end
 
   test "always nest doc" do
     # Consistent with definitions
     assert nest(empty(), 1) == {:doc_nest, empty(), 1, :always}
-    assert nest(empty(), 0) == :doc_nil
+    assert nest(empty(), 0) == []
 
     # Wrong argument type
     assert_raise FunctionClauseError, fn -> nest("foo", empty()) end
@@ -127,7 +127,7 @@ defmodule Inspect.AlgebraTest do
   test "break nest doc" do
     # Consistent with definitions
     assert nest(empty(), 1, :break) == {:doc_nest, empty(), 1, :break}
-    assert nest(empty(), 0, :break) == :doc_nil
+    assert nest(empty(), 0, :break) == []
 
     # Wrong argument type
     assert_raise FunctionClauseError, fn -> nest("foo", empty(), :break) end
@@ -188,7 +188,7 @@ defmodule Inspect.AlgebraTest do
 
   test "line doc" do
     # Consistent with definitions
-    assert line("a", "b") == {:doc_cons, "a", {:doc_cons, :doc_line, "b"}}
+    assert line("a", "b") == ["a", :doc_line | "b"]
 
     # Consistent formatting
     assert render(line(glue("aaa", "bbb"), glue("ccc", "ddd")), 10) == "aaa bbb\nccc ddd"

lib/elixir/test/elixir/kernel/alias_test.exs

@@ -62,7 +62,7 @@ defmodule Kernel.AliasTest do
     result = alias unquote(Inspect).{Opts, Algebra}
     assert result == [Inspect.Opts, Inspect.Algebra]
     assert %Opts{} == %Inspect.Opts{}
-    assert Algebra.empty() == :doc_nil
+    assert Algebra.empty() == []
   end
 
   test "alias removal" do