Disallow &-partial calls on the right side of |>

Author: alco

lib/elixir/lib/kernel.ex

@@ -2950,7 +2950,7 @@ defmodule Kernel do
   `|>` is called the pipeline operator as it is useful
   to write pipeline style expressions. This operator
   introduces the expression on the left as the first
-  argument to the expression on the right.
+  argument to the function call on the right.
 
   ## Examples
 
@@ -2961,8 +2961,8 @@ defmodule Kernel do
 
       Enum.map(List.flatten([1,[2],3]), &1 * 2)
 
-  Please be aware of operator precendence, when using
-  this operator. For example, the following expression:
+  Be aware of operator precendence when using this operator.
+  For example, the following expression:
 
       String.graphemes "Hello" |> Enum.reverse
 
@@ -2972,7 +2972,7 @@ defmodule Kernel do
 
   Which will result in an error as Enumerable protocol
   is not defined for binaries. Adding explicit parenthesis
-  is recommended:
+  resolves the ambiguity:
 
       String.graphemes("Hello") |> Enum.reverse
 
@@ -2989,7 +2989,11 @@ defmodule Kernel do
     { call, line, [left] }
   end
 
-  defp pipeline_op(left, { call, line, args }) when is_list(args) do
+  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
     { call, line, [left|args] }
   end
 
@@ -2998,7 +3002,17 @@ defmodule Kernel do
   end
 
   defp pipeline_op(_, other) do
-    raise ArgumentError, message: "Unsupported expression in pipeline |> operator: #{inspect other}"
+    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_binary arg}"
   end
 
   @doc """

lib/elixir/test/elixir/kernel_test.exs

@@ -227,6 +227,27 @@ defmodule KernelTest do
       assert __MODULE__ |> :constant == 13
     end
 
+    test "non-call" do
+      assert  1  |> (&1*2).() == 2
+      assert [1] |> hd(&1).() == 1
+
+      # FIXME: this mustn't work, but it doesn't call pipeline_op at all
+      #assert "Unsupported expression in pipeline |> operator: &1" = format_rescue("1 |> &1")
+      assert "Unsupported expression in pipeline |> operator: &1 * 2" = format_rescue("1 |> &1*2")
+      assert "Unsupported expression in pipeline |> operator: hd(&1)" = format_rescue("[1] |> hd(&1)")
+    end
+
+    defp format_rescue(expr) do
+      result = try do
+        :elixir.eval(to_char_list(expr), [])
+        nil
+      rescue
+        error -> error.message
+      end
+
+      result || raise(ExUnit.AssertionError, message: "Expected function given to format_rescue to fail")
+    end
+
     def constant, do: 13
 
     defp twice(a), do: a * 2