Add &local/arity and &Remote.fun/arity

José Valim · José Valim · commit b5428adda643 · 2013-07-31T12:58:07.000+02:00
diff --git a/lib/elixir/lib/inspect.ex b/lib/elixir/lib/inspect.ex
@@ -364,7 +364,7 @@ defimpl Inspect, for: Function do
     mod = fun_info[:module]
 
     if fun_info[:type] == :external and fun_info[:env] == [] do
-      "function(#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]})"
+      "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
     else
       case atom_to_list(mod) do
         'elixir_compiler_' ++ _ ->
diff --git a/lib/elixir/lib/kernel.ex b/lib/elixir/lib/kernel.ex
@@ -3216,30 +3216,12 @@ defmodule Kernel do
     { call, line, [left] }
   end
 
-  defp pipeline_op(left, { call, line, args }=right) when is_list(args) do
-    case validate_pipeline_args(args) do
-      :error -> pipeline_error(right)
-      _ -> nil
-    end
+  defp pipeline_op(left, { call, line, args }) when is_list(args) do
     { call, line, [left|args] }
   end
 
-  defp pipeline_op(left, atom) when is_atom(atom) do
-    { { :., [], [left, atom] }, [], [] }
-  end
-
-  defp pipeline_op(_, other) do
-    pipeline_error(other)
-  end
-
-  defp validate_pipeline_args([]), do: nil
-  defp validate_pipeline_args([ {:&, _, _ } | _ ]), do: :error
-  defp validate_pipeline_args([_|t]) do
-    validate_pipeline_args(t)
-  end
-
-  defp pipeline_error(arg) do
-    raise ArgumentError, message: "Unsupported expression in pipeline |> operator: #{Macro.to_string arg}"
+  defp pipeline_op(_, arg) do
+    raise ArgumentError, message: "unsupported expression in pipeline |> operator: #{Macro.to_string arg}"
   end
 
   @doc """
diff --git a/lib/elixir/lib/kernel/special_forms.ex b/lib/elixir/lib/kernel/special_forms.ex
@@ -852,6 +852,27 @@ defmodule Kernel.SpecialForms do
   """
   defmacro __block__(args)
 
+  @doc """
+  Captures a call as an anonymous function.
+
+  The most common format to capture a function is via module,
+  name and arity:
+
+      iex> fun = &Kernel.is_atom/1
+      iex> fun.(:atom)
+      true
+      iex> fun.("string")
+      false
+
+  Local functions, including private ones, and imported ones
+  can also be captured by omitting the module name:
+
+      &local_function/1
+
+  """
+  name = :&
+  defmacro unquote(name)(expr)
+
   @doc """
   This is the special form used whenever we have to temporarily
   change the scope information of a block. Used when `quote` is
diff --git a/lib/elixir/src/elixir_fn.erl b/lib/elixir/src/elixir_fn.erl
@@ -0,0 +1,42 @@
+-module(elixir_fn).
+-export([fn/3, capture/3]).
+-import(elixir_scope, [umergec/2]).
+-include("elixir.hrl").
+
+capture(Meta, { '/', _, [{ { '.', _, [M, F] }, _ , [] }, A] }, S) when is_atom(F), is_integer(A) ->
+  { [MF, FF, AF], SF } = elixir_translator:translate_args([M, F, A], S),
+  { { 'fun', ?line(Meta), { function, MF, FF, AF } }, SF };
+
+capture(Meta, { '/', _, [{ F, _, C }, A] }, S) when is_atom(F), is_integer(A), is_atom(C) ->
+  WrappedMeta =
+    case lists:keyfind(import_fa, 1, Meta) of
+      { import_fa, { Receiver, Context } } ->
+        lists:keystore(context, 1,
+          lists:keystore(import, 1, Meta, { import, Receiver }),
+          { context, Context }
+        );
+      false -> Meta
+    end,
+
+  case elixir_dispatch:import_function(WrappedMeta, F, A, S) of
+    false -> elixir_errors:compile_error(WrappedMeta, S#elixir_scope.file,
+                                         "expected ~ts/~B to be a function, but it is a macro", [F, A]);
+    Else  -> Else
+  end.
+
+fn(Meta, Clauses, S) ->
+  Transformer = fun({ ArgsWithGuards, CMeta, Expr }, Acc) ->
+    { Args, Guards } = elixir_clauses:extract_splat_guards(ArgsWithGuards),
+    elixir_clauses:assigns_block(?line(CMeta), fun elixir_translator:translate/2, Args, [Expr], Guards, umergec(S, Acc))
+  end,
+
+  { TClauses, NS } = lists:mapfoldl(Transformer, S, Clauses),
+  Arities = [length(Args) || { clause, _Line, Args, _Guards, _Exprs } <- TClauses],
+
+  case length(lists:usort(Arities)) of
+    1 ->
+      { { 'fun', ?line(Meta), { clauses, TClauses } }, umergec(S, NS) };
+    _ ->
+      elixir_errors:syntax_error(Meta, S#elixir_scope.file,
+                                 "cannot mix clauses with different arities in function definition")
+  end.
diff --git a/lib/elixir/src/elixir_macros.erl b/lib/elixir/src/elixir_macros.erl
@@ -5,9 +5,8 @@
 -import(elixir_translator, [translate_each/2, translate_args/2, translate_apply/7]).
 -import(elixir_scope, [umergec/2, umergea/2]).
 -import(elixir_errors, [compile_error/3, compile_error/4,
-  syntax_error/3, syntax_error/4,
-  assert_no_function_scope/3, assert_module_scope/3,
-  assert_no_match_or_guard_scope/3]).
+  syntax_error/3, syntax_error/4, assert_no_function_scope/3,
+  assert_module_scope/3, assert_no_match_or_guard_scope/3]).
 
 -include("elixir.hrl").
 -define(opt_in_types(Kind), Kind == atom orelse Kind == integer orelse Kind == float).
@@ -50,10 +49,12 @@ translate({ in, Meta, [Left, Right] }, #elixir_scope{extra_guards=Extra} = S) ->
   { TVar, TS#elixir_scope{extra_guards=[TExpr|Extra]} };
 
 %% Functions
+%% Once this function is removed, the related checks
+%% from quote needs to be removed too.
 
 translate({ function, Meta, [[{do,{ '->',_,Pairs}}]] }, S) ->
   assert_no_match_or_guard_scope(Meta, 'function', S),
-  elixir_translator:translate_fn(Meta, Pairs, S);
+  elixir_fn:fn(Meta, Pairs, S);
 
 translate({ function, _, [{ '/', _, [{{ '.', Meta, [M, F] }, _ , []}, A]}] }, S) when is_atom(F), is_integer(A) ->
   translate({ function, Meta, [M, F, A] }, S);
diff --git a/lib/elixir/src/elixir_parser.yrl b/lib/elixir/src/elixir_parser.yrl
@@ -481,7 +481,7 @@ Erlang code.
 
 %% Operators
 
-build_op({ _Kind, Line, '/' }, { '&', _, [{ _Kind, _, Atom } = Left] }, Right) when is_number(Right), is_atom(Atom) ->
+build_op({ _Kind, Line, '/' }, { '&', _, [{ Kind, _, Atom } = Left] }, Right) when is_number(Right), is_atom(Atom), is_atom(Kind) ->
   { '&', [{line,Line}], [{ '/', [{line,Line}], [Left, Right] }] };
 
 build_op({ _Kind, Line, '/' }, { '&', _, [{ { '.', _, [_, _] }, _, [] } = Left] }, Right) when is_number(Right) ->
@@ -490,7 +490,7 @@ build_op({ _Kind, Line, '/' }, { '&', _, [{ { '.', _, [_, _] }, _, [] } = Left]
 build_op({ _Kind, Line, BOp }, { UOp, _, [Left] }, Right) when ?rearrange_bop(BOp), ?rearrange_uop(UOp) ->
   { UOp, [{line,Line}], [{ BOp, [{line,Line}], [Left, Right] }] };
 
-build_op({ _Kind, Line, Op }, Left, Right) ->
+build_op({ _Kind, Line, Op } = A, Left, Right) ->
   { Op, [{line,Line}], [Left, Right] }.
 
 build_unary_op({ _Kind, Line, Op }, Expr) ->
diff --git a/lib/elixir/src/elixir_partials.erl b/lib/elixir/src/elixir_partials.erl
@@ -11,7 +11,7 @@ handle({ _, Meta, Args } = Original, S, Opt) when is_list(Args), S#elixir_scope.
     { Call, Def, SC } when Def /= [] ->
       Final = validate(Meta, Def, SC),
       Block = setelement(3, Original, Call),
-      elixir_translator:translate_fn(Meta, [{ Final, Meta, Block }], SC);
+      elixir_fn:fn(Meta, [{ Final, Meta, Block }], SC);
     _ -> error
   end;
 
diff --git a/lib/elixir/src/elixir_quote.erl b/lib/elixir/src/elixir_quote.erl
@@ -150,6 +150,10 @@ do_quote({ { '.', Meta, [Left, unquote] }, _, [Expr] }, #elixir_quote{unquote=tr
 
 %% Imports
 
+do_quote({ '&', Meta, [{ '/', _, [{F, _, C}, A]}] = Args },
+    #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(F), is_integer(A), is_atom(C) ->
+  do_quote_fa(function, Meta, Args, F, A, Q, S);
+
 do_quote({ function, Meta, [{ '/', _, [{F, _, C}, A]}] = Args },
     #elixir_quote{imports_hygiene=true} = Q, S) when is_atom(F), is_integer(A), is_atom(C) ->
   do_quote_fa(function, Meta, Args, F, A, Q, S);
diff --git a/lib/elixir/src/elixir_translator.erl b/lib/elixir/src/elixir_translator.erl
@@ -3,7 +3,7 @@
 -module(elixir_translator).
 -export([forms/4, 'forms!'/4]).
 -export([translate/2, translate_each/2, translate_arg/2,
-         translate_args/2, translate_apply/7, translate_fn/3]).
+         translate_args/2, translate_apply/7]).
 -import(elixir_scope, [umergev/2, umergec/2, umergea/2]).
 -import(elixir_errors, [syntax_error/3, syntax_error/4,
   compile_error/3, compile_error/4,
@@ -300,9 +300,13 @@ translate_each({ 'var!', Meta, [_, _] }, S) ->
 
 %% Functions
 
+translate_each({ '&', Meta, [Arg] }, S) ->
+  assert_no_match_or_guard_scope(Meta, '&', S),
+  elixir_fn:capture(Meta, Arg, S);
+
 translate_each({ fn, Meta, [[{do, { '->', _, Pairs }}]] }, S) ->
   assert_no_match_or_guard_scope(Meta, 'fn', S),
-  translate_fn(Meta, Pairs, S);
+  elixir_fn:fn(Meta, Pairs, S);
 
 %% Comprehensions
 
@@ -562,24 +566,6 @@ no_alias_expansion(Other) ->
 is_atom_tuple({ atom, _, _ }) -> true;
 is_atom_tuple(_) -> false.
 
-%% Function
-
-translate_fn(Meta, Clauses, S) ->
-  Transformer = fun({ ArgsWithGuards, CMeta, Expr }, Acc) ->
-    { Args, Guards } = elixir_clauses:extract_splat_guards(ArgsWithGuards),
-    elixir_clauses:assigns_block(?line(CMeta), fun elixir_translator:translate/2, Args, [Expr], Guards, umergec(S, Acc))
-  end,
-
-  { TClauses, NS } = lists:mapfoldl(Transformer, S, Clauses),
-  Arities = [length(Args) || { clause, _Line, Args, _Guards, _Exprs } <- TClauses],
-
-  case length(lists:usort(Arities)) of
-    1 ->
-      { { 'fun', ?line(Meta), { clauses, TClauses } }, umergec(S, NS) };
-    _ ->
-      syntax_error(Meta, S#elixir_scope.file, "cannot mix clauses with different arities in function definition")
-  end.
-
 %% Locals
 
 translate_local(Meta, Name, Args, #elixir_scope{local=nil,function=nil} = S) ->
diff --git a/lib/elixir/test/elixir/inspect_test.exs b/lib/elixir/test/elixir/inspect_test.exs
@@ -225,12 +225,12 @@ defmodule Inspect.OthersTest do
 
   test :external_elixir_funs do
     bin = inspect(function(Enum.map/2))
-    assert bin == "function(Enum.map/2)"
+    assert bin == "&Enum.map/2"
   end
 
   test :external_erlang_funs do
     bin = inspect(function(:lists.map/2))
-    assert bin == "function(:lists.map/2)"
+    assert bin == "&:lists.map/2"
   end
 
   test :other_funs do
diff --git a/lib/elixir/test/elixir/kernel/fn_test.exs b/lib/elixir/test/elixir/kernel/fn_test.exs
@@ -0,0 +1,27 @@
+Code.require_file "../test_helper.exs", __DIR__
+
+defmodule Kernel.FnTest do
+  use ExUnit.Case, async: true
+
+  test "capture remote" do
+    assert (&:erlang.atom_to_list/1).(:a) == 'a'
+    assert (&Kernel.atom_to_list/1).(:a) == 'a'
+
+    assert (&List.flatten/1).([[0]]) == [0]
+    assert (&(List.flatten/1)).([[0]]) == [0]
+  end
+
+  test "capture local" do
+    assert (&atl/1).(:a) == 'a'
+    assert (&(atl/1)).(:a) == 'a'
+  end
+
+  test "capture imported" do
+    assert (&atom_to_list/1).(:a) == 'a'
+    assert (&(atom_to_list/1)).(:a) == 'a'
+  end
+
+  defp atl(arg) do
+    :erlang.atom_to_list arg
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel_test.exs b/lib/elixir/test/elixir/kernel_test.exs
@@ -336,38 +336,30 @@ defmodule KernelTest do
   defmodule PipelineOp do
     use ExUnit.Case, async: true
 
-    test :simple do
+    test "simple" do
       assert [1, [2], 3] |> List.flatten == [1, 2, 3]
     end
 
-    test :nested do
+    test "nested pipelines" do
       assert [1, [2], 3] |> List.flatten |> Enum.map(&1 * 2) == [2, 4, 6]
     end
 
-    test :local do
+    test "local call" do
       assert [1, [2], 3] |> List.flatten |> local == [2, 4, 6]
     end
 
-    test :map do
+    test "pipeline with capture" do
       assert Enum.map([1, 2, 3], &1 |> twice |> twice) == [4, 8, 12]
     end
 
-    test :atom do
-      assert __MODULE__ |> :constant == 13
-    end
-
     test "non-call" do
       assert  1  |> (&1*2).() == 2
       assert [1] |> hd(&1).() == 1
 
       import CompileAssertion
-
-      assert_compile_fail ArgumentError, "Unsupported expression in pipeline |> operator: &1 * 2", "1 |> &1*2"
-      assert_compile_fail ArgumentError, "Unsupported expression in pipeline |> operator: hd(&1)", "[1] |> hd(&1)"
+      assert_compile_fail ArgumentError, "unsupported expression in pipeline |> operator: 2", "1 |> 2"
     end
 
-    def constant, do: 13
-
     defp twice(a), do: a * 2
 
     defp local(list) do
diff --git a/lib/elixir/test/erlang/function_test.erl b/lib/elixir/test/erlang/function_test.erl
@@ -35,7 +35,7 @@ function_with_kv_args_test() ->
   {Fun, _} = eval("fn(a, [other: b, another: c]) -> a + b + c end"),
   6 = Fun(1,[{other,2}, {another,3}]).
 
-function_as_clojure_test() ->
+function_as_closure_test() ->
   {_, [{a, Res1}|_]} = eval("b = 1; a = fn -> b + 2 end"),
   3 = Res1().
 
@@ -57,13 +57,6 @@ function_parens_test() ->
   {1,_} = eval("(fn (1) -> 1 end).(1)"),
   {3,_} = eval("(fn (1, 2) -> 3 end).(1, 2)").
 
-function_macro_parens_test() ->
-  {0,_} = eval("(function do () -> 0 end).()"),
-  {1,_} = eval("(function do 1 -> 1 end).(1)"),
-  {3,_} = eval("(function do 1, 2 -> 3 end).(1, 2)"),
-  {1,_} = eval("(function do (1) -> 1 end).(1)"),
-  {3,_} = eval("(function do (1, 2) -> 3 end).(1, 2)").
-
 %% Function calls
 
 function_call_test() ->
