Deprecate (fun(...) -> ...) spec style

We are deprecating this style because it reads ambiguous
as a function that receives another function as argument.

Author: José Valim

lib/elixir/lib/kernel/typespec.ex

@@ -50,22 +50,16 @@ defmodule Kernel.Typespec do
 
   Any anonymous function:
 
-      (fun(...) -> any)
-      or
       ((...) -> any)
       or
       (... -> any)
 
   Anonymous function with arity of zero:
 
-      (fun() -> type)
-      or
       (() -> type)
 
   Anonymous function with some arity:
 
-      (fun(type, type) -> type)
-      or
       ((type, type) -> type)
       or
       (type, type -> type)
@@ -475,12 +469,12 @@ defmodule Kernel.Typespec do
 
   defp typespec_to_ast({ :var, line, var }) do
     var =
-    case atom_to_binary(var) do
-      <<"_", c :: [binary, size(1)], rest :: binary>> ->
-        binary_to_atom("_#{String.downcase(c)}#{rest}")
-      <<c :: [binary, size(1)], rest :: binary>> ->
-        binary_to_atom("#{String.downcase(c)}#{rest}")
-    end
+      case atom_to_binary(var) do
+        <<"_", c :: [binary, size(1)], rest :: binary>> ->
+          binary_to_atom("_#{String.downcase(c)}#{rest}")
+        <<c :: [binary, size(1)], rest :: binary>> ->
+          binary_to_atom("#{String.downcase(c)}#{rest}")
+      end
     { var, line, nil }
   end
 
@@ -569,6 +563,8 @@ defmodule Kernel.Typespec do
 
   # Handle funs
   defp typespec({:->, meta, [{[{:fun, _, arguments}], cmeta, return}]}, vars, caller) when is_list(arguments) do
+    IO.warn "(fun(...) -> ...) in typespecs is deprecated, please drop fun() and " <>
+            "write (... -> ...) instead. #{Exception.format_stacktrace(caller.stacktrace)}"
     typespec({:->, meta, [{arguments, cmeta, return}]}, vars, caller)
   end
 

lib/elixir/test/elixir/typespec_test.exs

@@ -166,18 +166,13 @@ defmodule Typespec.TypeTest do
     assert {:mytype, {:type, _, :fun, []}, []} = spec
   end
 
-  test "@type with a fun with arguments and return type" do
-    {spec1, spec2} = test_module do
-      t1 = @type mytype :: (integer, integer -> integer)
-      t2 = @type mytype2 :: (fun(integer, integer) -> integer)
-      {t1, t2}
+  test "@type with a fun with multiple arguments and return type" do
+    t = test_module do
+      @type mytype :: (integer, integer -> integer)
     end
     assert {:mytype, {:type, _, :fun, [{:type, _, :product,
              [{:type, _, :integer, []}, {:type, _, :integer, []}]},
-             {:type, _, :integer, []}]}, []} = spec1
-    assert {:mytype2, {:type, _, :fun, [{:type, _, :product,
-             [{:type, _, :integer, []}, {:type, _, :integer, []}]},
-             {:type, _, :integer, []}]}, []} = spec2
+             {:type, _, :integer, []}]}, []} = t
   end
 
   test "@type with a fun with no arguments and return type" do