function(:is_atom, 1) is deprecated in favor of function(is_atom/1)

This is required so we can identity the proper function/arity
from quoting and properly hygienize function retrievals.

Author: José Valim

CHANGELOG.md

@@ -21,6 +21,7 @@
 
 * deprecations
   * [Kernel] `setelem/3` is deprecated in favor of `set_elem/3`
+  * [Kernel] `function(:is_atom, 1)` is deprecated in favor of `function(is_atom/1)`
 
 * backwards incompatible changes
   * [Kernel] `unquote` now only applies to the closest quote. If your code contains a quote that contains another quote that calls unquote, it will no longer work. Use `Macro.escape` instead and pass your quoted contents up in steps, for example:

lib/elixir/include/elixir.hrl

@@ -29,8 +29,11 @@
   aliases,                 %% an orddict with aliases by new -> old names
   file,                    %% the current scope filename
   requires,                %% a set with modules required
-  macros,                  %% a list with macros imported by module
-  functions}).             %% a list with functions imported by module
+  macro_macros,            %% a list with macros imported from module inside a macro
+  macros,                  %% a list with macros imported from module
+  macro_functions,         %% a list with functions imported from module inside a macro
+  functions                %% a list with functions imported from module
+}).
 
 -record(elixir_quote, {
   line=0,

lib/elixir/lib/kernel.ex

@@ -2089,9 +2089,10 @@ defmodule Kernel do
   end
 
   @doc """
-  Returns an anonymous function based on the given arguments.
+  Construct an anonymous function based on the given expression
+  or retrieve an existing one.
 
-  ## Examples
+  ## Function composition
 
       iex> sum = function do
       ...>   (x, y) -> x + y
@@ -2112,6 +2113,26 @@ defmodule Kernel do
       ...> sum.(1, 2)
       3
 
+  All clauses must expect the same number of arguments.
+
+  ## Function retrieval
+
+  The `function` macro can also be used to retrieve local, imported
+  and remote functions.
+
+      # Retrieve local/import
+      iex> f = function(is_atom/1)
+      iex> f.(:foo)
+      true
+
+      # Retrieve remote
+      iex> f = function(Kernel.is_atom/1)
+      iex> f.(:foo)
+      true
+
+  In case a function needs to be dynamically retrieved based on its
+  module, name or arity, use `function/3` instead.
+
   ## Shortcut syntax
 
   In order to reduce verbosity, functions in Elixir can be written
@@ -2151,54 +2172,14 @@ defmodule Kernel do
   defmacro function(args)
 
   @doc """
-  Retrieves a local or an imported function.
-
-  ## Examples
-
-      iex> f = function(:is_atom, 1)
-      ...> f.(:foo)
-      true
-
-  Notice that local functions cannot be retrieved dynamically,
-  the following, for example, wouldn't work:
-
-      some_fun = :is_atom
-      function(some_fun, 1)
-
-  In such cases, one should use `function/3`:
-
-      some_fun = :is_atom
-      function(SomeModule, some_fun, 1)
-
-  ## Shortcut syntax
-
-  One can use a shortcut syntax to retrieve such functions,
-  that resembles Erlang's `fun`:
-
-      f = function(is_atom/1)
-      f.(:foo)
-
-  """
-  defmacro function(function, arity)
-
-  @doc """
-  Retrieves a function from a module.
+  Retrieves a function with given name and arity from a module.
 
   ## Examples
 
       iex> f = function(Kernel, :is_atom, 1)
       ...> f.(:foo)
       true
 
-  ## Shortcut syntax
-
-  One can use a shortcut syntax to retrieve such functions,
-  that resembles Erlang's `fun`:
-
-      iex> f = function(Kernel.is_atom/1)
-      ...> f.(:foo)
-      true
-
   """
   defmacro function(module, function, arity)
 

lib/elixir/src/elixir_macros.erl

@@ -56,11 +56,16 @@ translate({ function, Meta, [[{do,{ '->',_,Pairs}}]] }, S) ->
   assert_no_match_or_guard_scope(Meta, 'function', S),
   elixir_translator:translate_fn(Meta, Pairs, S);
 
-translate({ function, Meta, [{ '/', _, [{{ '.', _ ,[M, F] }, _ , [] }, A]}] }, S) ->
+translate({ function, Meta, [{ '/', _, [{{ '.', _ ,[M, F] }, _ , [] }, A]}] }, S) when is_atom(F), is_integer(A) ->
   translate({ function, Meta, [M, F, A] }, S);
 
-translate({ function, Meta, [{ '/', _, [{F, _, Q}, A]}] }, S) when is_atom(Q) ->
-  translate({ function, Meta, [F, A] }, S);
+translate({ function, Meta, [{ '/', _, [{F, _, C}, A]}] }, S) when is_atom(F), is_integer(A), is_atom(C) ->
+  assert_no_match_or_guard_scope(Meta, 'function', S),
+
+  case elixir_dispatch:import_function(Meta, F, A, S) of
+    false -> syntax_error(Meta, S#elixir_scope.file, "cannot convert a macro to a function");
+    Else  -> Else
+  end;
 
 translate({ function, Meta, [_] }, S) ->
   assert_no_match_or_guard_scope(Meta, 'function', S),
@@ -71,6 +76,7 @@ translate({ function, Meta, [_, _] = Args }, S) ->
 
   case translate_args(Args, S) of
     { [{atom,_,Name}, {integer,_,Arity}], SA } ->
+      elixir_errors:deprecation(Meta, S#elixir_scope.file, "function(:~ts, ~B) is deprecated, please use function(~ts/~B)", [Name, Arity, Name, Arity]),
       case elixir_dispatch:import_function(Meta, Name, Arity, SA) of
         false -> syntax_error(Meta, S#elixir_scope.file, "cannot convert a macro to a function");
         Else  -> Else

lib/elixir/test/elixir/kernel_test.exs

@@ -141,41 +141,26 @@ defmodule KernelTest do
   defmodule Function do
     use ExUnit.Case, async: true
 
-    test :retrieve_remote_function do
-      assert is_function(function(:erlang, :atom_to_list, 1))
-      assert :erlang.fun_info(function(:erlang, :atom_to_list, 1), :arity) == {:arity, 1}
-      assert function(:erlang, :atom_to_list, 1).(:a) == 'a'
-    end
-
     test :remote_syntax_function do
+      assert function(:erlang, :atom_to_list, 1).(:a) == 'a'
       assert function(:erlang.atom_to_list/1) ==
              function(:erlang, :atom_to_list, 1)
       assert function(Enum.map/2) == function(Enum, :map, 2)
     end
 
-    test :retrieve_local_function do
-      assert is_function(function(:atl, 1))
-      assert :erlang.fun_info(function(:atl, 1), :arity) == {:arity, 1}
-      assert function(:atl, 1).(:a) == 'a'
-    end
-
     test :local_syntax_function do
       assert function(atl/1).(:a) == 'a'
     end
 
     test :retrieve_imported_function do
-      assert is_function(function(:atom_to_list, 1))
-      assert :erlang.fun_info(function(:atom_to_list, 1), :arity) == {:arity, 1}
-      assert function(:atom_to_list, 1).(:a) == 'a'
+      assert function(atom_to_list/1).(:a) == 'a'
     end
 
     test :retrieve_dynamic_function do
       a = :erlang
       b = :atom_to_list
       c = 1
 
-      assert is_function(function(a, b, c))
-      assert :erlang.fun_info(function(a, b, c), :arity) == {:arity, 1}
       assert function(a, b, c).(:a) == 'a'
     end