Invert the precedence of | and when

Although this adds some drawbacks when it comes to typespecs,
it prepares us for when we have named patterns.

Author: José Valim

lib/elixir/lib/behaviour.ex

@@ -46,12 +46,9 @@ defmodule Behaviour do
   @doc """
   Define a function callback according to the given type specification.
   """
-  defmacro defcallback({ :when, _, [{ :::, _, [fun, return] }, guards] }) do
-    do_defcallback(fun, return, guards, __CALLER__)
-  end
-
-  defmacro defcallback({ :::, _, [fun, return] }) do
-    do_defcallback(fun, return, [], __CALLER__)
+  defmacro defcallback({ :::, _, [fun, return_and_guard] }) do
+    { return, guard } = split_return_and_guard(return_and_guard)
+    do_defcallback(fun, return, guard, __CALLER__)
   end
 
   defmacro defcallback(fun) do
@@ -61,18 +58,28 @@ defmodule Behaviour do
   @doc """
   Define a macro callback according to the given type specification.
   """
-  defmacro defmacrocallback({ :when, _, [{ :::, _, [fun, return] }, guards] }) do
-    do_defcallback(fun, return, guards, __CALLER__)
-  end
-
-  defmacro defmacrocallback({ :::, _, [fun, return] }) do
-    do_defmacrocallback(fun, return, [], __CALLER__)
+  defmacro defmacrocallback({ :::, _, [fun, return_and_guard] }) do
+    { return, guard } = split_return_and_guard(return_and_guard)
+    do_defmacrocallback(fun, return, guard, __CALLER__)
   end
 
   defmacro defmacrocallback(fun) do
     do_defmacrocallback(fun, quote(do: Macro.t), [], __CALLER__)
   end
 
+  defp split_return_and_guard({ :when, _, [return, guard] }) do
+    { return, guard }
+  end
+
+  defp split_return_and_guard({ :|, meta, [left, right] }) do
+    { return, guard } = split_return_and_guard(right)
+    { { :|, meta, [left, return] }, guard }
+  end
+
+  defp split_return_and_guard(other) do
+    { other, [] }
+  end
+
   defp do_defcallback(fun, return, guards, caller) do
     case Macro.decompose_call(fun) do
       { name, args } ->
@@ -112,7 +119,7 @@ defmodule Behaviour do
   end
 
   defp ensure_not_default({ ://, _, [_, _] }) do
-    raise ArgumentError, message: "default arguments // not supported in defcallback"
+    raise ArgumentError, message: "default arguments // not supported in defcallback/defmacrocallback"
   end
 
   defp ensure_not_default(_), do: :ok

lib/elixir/lib/kernel/typespec.ex

@@ -19,7 +19,7 @@ defmodule Kernel.Typespec do
 
   Most of the built-in types provided in Erlang (for example, `pid()`) are
   expressed the same way: `pid()` or simply `pid`. Parametrized types are also
-  supported (`list(integer`) and so are remote types (`Enum.t`).
+  supported (`list(integer)`) and so are remote types (`Enum.t`).
 
   Integers and atom literals are allowed as types (ex. `1`, `:atom` or
   `false`). All other types are built of unions of predefined types. Certain
@@ -353,19 +353,21 @@ defmodule Kernel.Typespec do
   Converts a spec clause back to Elixir AST.
   """
   def spec_to_ast(name, { :type, line, :fun, [{:type, _, :product, args}, result] }) do
-    ast_args = lc arg inlist args, do: typespec_to_ast(arg)
-    ast = { :::, [line: line], [{ name, [line: line], ast_args }, typespec_to_ast(result)] }
+    meta = [line: line]
+    body = { name, meta, Enum.map(args, &typespec_to_ast/1) }
 
     vars = args ++ [result]
       |> Enum.flat_map(&collect_vars/1)
       |> Enum.uniq
-      |> Enum.map(&{ &1, { :var, [line: line], nil } })
+      |> Enum.map(&{ &1, { :var, meta, nil } })
 
-    unless vars == [] do
-      ast = { :when, [line: line], [ast, vars] }
+    result = if vars == [] do
+      typespec_to_ast(result)
+    else
+      { :when, meta, [typespec_to_ast(result), vars] }
     end
 
-    ast
+    { :::, meta, [body, result] }
   end
 
   def spec_to_ast(name, { :type, line, :fun, [] }) do
@@ -378,16 +380,20 @@ defmodule Kernel.Typespec do
         { var, typespec_to_ast(type) }
       end
 
-    ast_args = lc arg inlist args, do: typespec_to_ast(arg)
+    meta = [line: line]
 
     vars = args ++ [result]
       |> Enum.flat_map(&collect_vars/1)
       |> Enum.uniq
+      |> Kernel.--(Keyword.keys(guards))
+      |> Enum.map(&{ &1, { :var, meta, nil } })
 
-    vars = vars -- Keyword.keys(guards)
-      |> Enum.map(&{ &1, { :var, [line: line], nil } })
+    args = lc arg inlist args, do: typespec_to_ast(arg)
 
-    { :when, [line: line], [{ :::, [line: line], [{ name, [line: line], ast_args }, typespec_to_ast(result)] }, guards ++ vars] }
+    { :::, meta, [
+      { name, [line: line], args },
+      { :when, meta, [typespec_to_ast(result), guards ++ vars] }
+    ] }
   end
 
   @doc """
@@ -473,7 +479,7 @@ defmodule Kernel.Typespec do
   The result is returned as a list of tuples where the first
   element is spec name and arity and the second is the spec.
 
-  The module must have a corresponding beam file 
+  The module must have a corresponding beam file
   which can be located by the runtime system.
   """
   @spec beam_callbacks(module | binary) :: [tuple] | nil
@@ -524,7 +530,7 @@ defmodule Kernel.Typespec do
 
   def deftype(_kind, other, caller) do
     type_spec = Macro.to_string(other)
-    compile_error caller, "invalid type specification `#{type_spec}`"
+    compile_error caller, "invalid type specification: #{type_spec}"
   end
 
   defp do_deftype(kind, { name, _, args }, definition, caller) do
@@ -545,16 +551,17 @@ defmodule Kernel.Typespec do
   end
 
   @doc false
-  def defspec(type, { :when, meta2, [{ :::, _, [{ name, meta, args }, return] }, guard] }, caller) do
+  def defspec(type, { :::, meta, [{ name, _, args }, return_and_guard] }, caller) do
     if is_atom(args), do: args = []
+    { return, guard } = split_return_and_guard(return_and_guard)
 
     unless Keyword.keyword?(guard) do
       guard = Macro.to_string(guard)
-      compile_error caller, "invalid guard in function type specification `#{guard}`"
+      compile_error caller, "expected keywords as guard in function type specification, got: #{guard}"
     end
 
     vars = Keyword.keys(guard)
-    constraints = guard_to_constraints(guard, vars, meta2, caller)
+    constraints = guard_to_constraints(guard, vars, meta, caller)
 
     spec = { :type, line(meta), :fun, fn_args(meta, args, return, vars, caller) }
     if constraints != [] do
@@ -566,17 +573,22 @@ defmodule Kernel.Typespec do
     code
   end
 
-  def defspec(type, { :::, _, [{ name, meta, args }, return] }, caller) do
-    if is_atom(args), do: args = []
-    spec = { :type, line(meta), :fun, fn_args(meta, args, return, [], caller) }
-    code = { { name, Kernel.length(args) }, spec }
-    Module.compile_typespec(caller.module, type, code)
-    code
-  end
-
   def defspec(_type, other, caller) do
     spec = Macro.to_string(other)
-    compile_error caller, "invalid function type specification `#{spec}`"
+    compile_error caller, "invalid function type specification: #{spec}"
+  end
+
+  defp split_return_and_guard({ :when, _, [return, guard] }) do
+    { return, guard }
+  end
+
+  defp split_return_and_guard({ :|, meta, [left, right] }) do
+    { return, guard } = split_return_and_guard(right)
+    { { :|, meta, [left, return] }, guard }
+  end
+
+  defp split_return_and_guard(other) do
+    { other, [] }
   end
 
   defp guard_to_constraints(guard, vars, meta, caller) do
@@ -656,8 +668,7 @@ defmodule Kernel.Typespec do
 
   defp typespec_to_ast({ :type, line, :union, args }) do
     args = lc arg inlist args, do: typespec_to_ast(arg)
-    Enum.reduce tl(args), hd(args),
-      fn(arg, expr) -> { :|, [line: line], [expr, arg] } end
+    Enum.reduce Enum.reverse(args), fn(arg, expr) -> { :|, [line: line], [arg, expr] } end
   end
 
   defp typespec_to_ast({ :type, line, :fun, [{:type, _, :product, args}, result] }) do
@@ -749,7 +760,7 @@ defmodule Kernel.Typespec do
 
   # Handle unions
   defp typespec({ :|, meta, [_, _] } = exprs, vars, caller) do
-    exprs = Enum.reverse(collect_union(exprs))
+    exprs = collect_union(exprs)
     union = lc e inlist exprs, do: typespec(e, vars, caller)
     { :type, line(meta), :union, union }
   end
@@ -886,9 +897,10 @@ defmodule Kernel.Typespec do
     typespec({ :nonempty_list, [], [spec] }, vars, caller)
   end
 
-  defp typespec([h|t] = l, vars, caller) do
-    union = Enum.reduce(t, validate_kw(h, l, caller), fn(x, acc) ->
-      { :|, [], [acc, validate_kw(x, l, caller)] }
+  defp typespec(list, vars, caller) do
+    [h|t] = Enum.reverse(list)
+    union = Enum.reduce(t, validate_kw(h, list, caller), fn(x, acc) ->
+      { :|, [], [validate_kw(x, list, caller), acc] }
     end)
     typespec({ :list, [], [union] }, vars, caller)
   end
@@ -904,12 +916,12 @@ defmodule Kernel.Typespec do
     { :remote_type, line(meta), [ remote, name, arguments ] }
   end
 
-  defp collect_union({ :|, _, [a, b] }), do: [b|collect_union(a)]
+  defp collect_union({ :|, _, [a, b] }), do: [a|collect_union(b)]
   defp collect_union(v), do: [v]
 
   defp validate_kw({ key, _ } = t, _, _caller) when is_atom(key), do: t
   defp validate_kw(_, original, caller) do
-    compile_error(caller, "unexpected list `#{Macro.to_string original}` in typespec")
+    compile_error(caller, "unexpected list in typespec: #{Macro.to_string original}")
   end
 
   defp fn_args(meta, args, return, vars, caller) do

lib/elixir/lib/macro.ex

@@ -30,11 +30,9 @@ defmodule Macro do
   @spec binary_op_props(atom) :: { :left | :right, precedence :: integer }
   defp binary_op_props(o) do
     case o do
-      :when                                                     -> {:right, 30}
       :::                                                       -> {:right, 40}
-      o when o in [:inlist, :inbits]                            -> {:left, 50}
-      ://                                                       -> {:right, 60}
-      :|                                                        -> {:left, 70}
+      o when o in [:inlist, :inbits, ://, :|]                   -> {:right, 50}
+      :when                                                     -> {:right, 70}
       :=                                                        -> {:right, 80}
       o when o in [:||, :|||, :or, :xor]                        -> {:left, 130}
       o when o in [:&&, :&&&, :and]                             -> {:left, 140}

lib/elixir/src/elixir_parser.yrl

@@ -3,10 +3,9 @@ Nonterminals
   expr container_expr block_expr no_parens_expr identifier_expr max_expr
   bracket_expr bracket_at_expr base_expr matched_expr unmatched_expr
   op_expr matched_op_expr no_parens_op_expr
-  comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol tail_op_eol
+  comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol
   add_op_eol mult_op_eol exp_op_eol two_op_eol type_op_eol stab_op_eol
-  arrow_op_eol default_op_eol match_op_eol
-  when_op_eol in_op_eol inc_op_eol
+  arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol
   open_paren close_paren empty_paren
   open_bracket close_bracket
   open_curly close_curly
@@ -30,9 +29,8 @@ Terminals
   fn 'end' aliases
   number signed_number atom atom_string bin_string list_string sigil
   dot_call_op op_identifier
-  comp_op at_op unary_op and_op or_op arrow_op match_op
-  in_op inc_op when_op default_op tail_op
-  dual_op add_op mult_op exp_op two_op type_op stab_op
+  comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op
+  dual_op add_op mult_op exp_op two_op type_op stab_op when_op
   'true' 'false' 'nil' 'do' eol ',' '.' '&'
   '(' ')' '[' ']' '{' '}' '<<' '>>'
   .
@@ -46,11 +44,9 @@ Expect 2.
 Left       5 do.
 Right     10 stab_op_eol.     %% ->
 Left      20 ','.
-Right     30 when_op_eol.     %% when
 Right     40 type_op_eol.     %% ::
-Left      50 inc_op_eol.      %% inlist, inbits
-Right     60 default_op_eol.  %% //
-Left      70 tail_op_eol.     %% |
+Right     50 in_match_op_eol. %% inlist, inbits, //, | (allowed in matches, lower precedence than =)
+Right     70 when_op_eol.     %% when
 Right     80 match_op_eol.    %% =
 Left     130 or_op_eol.       %% ||, |||, or, xor
 Left     140 and_op_eol.      %% &&, &&&, and
@@ -138,11 +134,9 @@ op_expr -> exp_op_eol expr : { '$1', '$2' }.
 op_expr -> two_op_eol expr : { '$1', '$2' }.
 op_expr -> and_op_eol expr : { '$1', '$2' }.
 op_expr -> or_op_eol expr : { '$1', '$2' }.
-op_expr -> tail_op_eol expr : { '$1', '$2' }.
 op_expr -> in_op_eol expr : { '$1', '$2' }.
-op_expr -> inc_op_eol expr : { '$1', '$2' }.
+op_expr -> in_match_op_eol expr : { '$1', '$2' }.
 op_expr -> when_op_eol expr : { '$1', '$2' }.
-op_expr -> default_op_eol expr : { '$1', '$2' }.
 op_expr -> type_op_eol expr : { '$1', '$2' }.
 op_expr -> comp_op_eol expr : { '$1', '$2' }.
 op_expr -> arrow_op_eol expr : { '$1', '$2' }.
@@ -154,10 +148,8 @@ no_parens_op_expr -> exp_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> two_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> and_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> or_op_eol no_parens_expr : { '$1', '$2' }.
-no_parens_op_expr -> tail_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> in_op_eol no_parens_expr : { '$1', '$2' }.
-no_parens_op_expr -> inc_op_eol no_parens_expr : { '$1', '$2' }.
-no_parens_op_expr -> default_op_eol no_parens_expr : { '$1', '$2' }.
+no_parens_op_expr -> in_match_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> type_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> comp_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> arrow_op_eol no_parens_expr : { '$1', '$2' }.
@@ -173,11 +165,9 @@ matched_op_expr -> exp_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> two_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> and_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> or_op_eol matched_expr : { '$1', '$2' }.
-matched_op_expr -> tail_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> in_op_eol matched_expr : { '$1', '$2' }.
-matched_op_expr -> inc_op_eol matched_expr : { '$1', '$2' }.
+matched_op_expr -> in_match_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> when_op_eol matched_expr : { '$1', '$2' }.
-matched_op_expr -> default_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> type_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> comp_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> arrow_op_eol matched_expr : { '$1', '$2' }.
@@ -307,9 +297,6 @@ exp_op_eol -> exp_op eol : '$1'.
 two_op_eol -> two_op : '$1'.
 two_op_eol -> two_op eol : '$1'.
 
-default_op_eol -> default_op : '$1'.
-default_op_eol -> default_op eol : '$1'.
-
 type_op_eol -> type_op : '$1'.
 type_op_eol -> type_op eol : '$1'.
 
@@ -327,14 +314,11 @@ and_op_eol -> and_op eol : '$1'.
 or_op_eol -> or_op : '$1'.
 or_op_eol -> or_op eol : '$1'.
 
-tail_op_eol -> tail_op : '$1'.
-tail_op_eol -> tail_op eol : '$1'.
-
 in_op_eol -> in_op : '$1'.
 in_op_eol -> in_op eol : '$1'.
 
-inc_op_eol -> inc_op : '$1'.
-inc_op_eol -> inc_op eol : '$1'.
+in_match_op_eol -> in_match_op : '$1'.
+in_match_op_eol -> in_match_op eol : '$1'.
 
 when_op_eol -> when_op : '$1'.
 when_op_eol -> when_op eol : '$1'.