Inspect should represent non valid terms with #

Author: José Valim

lib/elixir/lib/binary/inspect.ex

@@ -11,7 +11,7 @@ defprotocol Binary.Inspect do
   printing.
   """
 
-  @only [BitString, List, Tuple, Atom, Number, Function, Any]
+  @only [BitString, List, Tuple, Atom, Number, Function, PID, Port, Reference]
 
   def inspect(thing, opts)
 end
@@ -419,32 +419,41 @@ end
 
 defimpl Binary.Inspect, for: Function do
   @moduledoc """
-  Represents functions, in a literal form, when possible
+  Inspect functions, when possible, in a literal form.
   """
 
-  def inspect(thing, _opts) do
-    fun_info = :erlang.fun_info(thing)
-    if fun_info[:type] == :external and
-       fun_info[:env] == [] do
+  def inspect(function, _opts) do
+    fun_info = :erlang.fun_info(function)
+    if fun_info[:type] == :external and fun_info[:env] == [] do
       "function(#{Kernel.inspect(fun_info[:module])}.#{fun_info[:name]}/#{fun_info[:arity]})"
     else
-      iolist_to_binary :io_lib.format('~p', [thing])
+      '#Fun' ++ rest = :erlang.fun_to_list(function)
+      "#Function" <> list_to_binary(rest)
     end
   end
 end
 
-defimpl Binary.Inspect, for: Any do
-  @moduledoc """
-  For all other terms not implemented, we use the default
-  Erlang representation.
+defimpl Binary.Inspect, for: PID do
+  @moduledoc "Inspect PIDs"
 
-  ## Examples
+  def inspect(pid, _) do
+    "#PID" <> list_to_binary pid_to_list(pid)
+  end
+end
 
-      inspect Process.self #=> "<0.35.0>"
+defimpl Binary.Inspect, for: Port do
+  @moduledoc "Inspect ports"
 
-  """
+  def inspect(port, _) do
+    list_to_binary :erlang.port_to_list(port)
+  end
+end
 
-  def inspect(thing, _) do
-    iolist_to_binary :io_lib.format('~p', [thing])
+defimpl Binary.Inspect, for: Reference do
+  @moduledoc "Inspect references"
+
+  def inspect(ref, _) do
+    '#Ref' ++ rest = :erlang.ref_to_list(ref)
+    "#Reference" <> list_to_binary(rest)
   end
-end
+end

lib/elixir/lib/hash_dict.ex

@@ -489,6 +489,6 @@ defimpl Binary.Inspect, for: HashDict do
   import Kernel, except: [inspect: 2]
 
   def inspect(dict, opts) do
-    "HashDict" <> Binary.Inspect.inspect(HashDict.to_list(dict), opts)
+    "#HashDict<" <> Binary.Inspect.inspect(HashDict.to_list(dict), opts) <> ">"
   end
 end

lib/elixir/lib/kernel.ex

@@ -1798,7 +1798,7 @@ defmodule Kernel do
   end
 
   @doc """
-  Inspect the given arguments according to the Binary.Inspect protocol.
+  Inspect the given arguments according to the `Binary.Inspect` protocol.
 
   ## Options
 
@@ -1815,6 +1815,13 @@ defmodule Kernel do
       inspect(:foo)
       #=> ":foo"
 
+  Notice the inspect protocol does not necessarily return a valid Elixir
+  terms representation. In such cases, the inspected result must start
+  with `#`. For example, inspecting a function will return:
+
+      inspect &1 + &2
+      #=> #Function<...>
+
   """
   defmacro inspect(arg, opts // []) do
     quote do: Binary.Inspect.inspect(unquote(arg), unquote(opts))

lib/elixir/lib/tuple.ex

@@ -1,2 +1,3 @@
 defmodule Tuple do
+  @moduledoc false
 end

lib/elixir/test/elixir/binary/inspect_test.exs

@@ -185,46 +185,35 @@ defmodule Binary.Inspect.ListTest do
   end
 end
 
-defmodule Binary.Inspect.FunctionTest do
+defmodule Binary.Inspect.OthersTest do
   use ExUnit.Case, async: true
 
   def f do
     fn() -> :ok end
   end
 
-  test :funs do
-    bin = inspect(fn(x) -> x + 1 end)
-    assert '#Fun<' ++ _ = binary_to_list(bin)
-  end
-
-  test :external_elixir do
+  test :external_elixir_funs do
     bin = inspect(function(Enum.map/2))
     assert bin == "function(Enum.map/2)"
   end
 
-  test :external_elixir_fun do
-    bin = inspect(f)
-    assert '#Fun<' ++ _ = binary_to_list(bin)
-  end
-
-  test :external_erlang do
+  test :external_erlang_funs do
     bin = inspect(function(:lists.map/2))
     assert bin == "function(:lists.map/2)"
   end
 
-end
-
-defmodule Binary.Inspect.AnyTest do
-  use ExUnit.Case, async: true
+  test :other_funs do
+    assert "#Function<" <> _ = inspect(fn(x) -> x + 1 end)
+    assert "#Function<" <> _ = inspect(f)
+  end
 
-  test :funs do
-    bin = inspect(fn(x) -> x + 1 end)
-    assert '#Fun<' ++ _ = binary_to_list(bin)
+  test :pids do
+    assert "#PID<" <> _ = inspect(self)
   end
-end
 
-defmodule Binary.Inspect.RegexTest do
-  use ExUnit.Case, async: true
+  test :references do
+    assert "#Reference<" <> _ = inspect(make_ref)
+  end
 
   test :regex do
     "%r\"foo\"m" = inspect(%r(foo)m)

lib/elixir/test/elixir/hash_dict_test.exs

@@ -132,7 +132,7 @@ defmodule HashDictTest do
   end
 
   test :inspect do
-    assert inspect(filled_dict(8)) =~ %r"HashDict\["
+    assert inspect(filled_dict(8)) =~ %r"#HashDict<"
   end
 
   test :small_range_merge do