Normalize is_guard checks

Author: José Valim

CHANGELOG.md

@@ -27,7 +27,10 @@
 
 * Deprecations
   * [Collectable] Deprecate `Collectable.empty/1` and `Enum.traverse/2`
+  * [Integer] `odd?/1` and `even?/1` are deprecated in favor of `is_odd/1` and `is_even/1`
+  * [Kernel] `nil?/1` is deprecated in favor of `is_nil/1`
   * [Kernel] `x.Alias` is deprecated in favor of an explicit `Module.concat/2`
+  * [Record] `record?/1` and `record?/2` are deprecated in favor of `is_record/1` and `is_record/2`
   * [Stream] Returning `{item, acc} | nil` from `Stream.resource/2` is deprecated, instead return `{[item], acc} | {:halt, acc}` (similar to `Stream.transform/3`)
 
 * Backwards incompatible changes

lib/elixir/lib/collectable.ex

@@ -82,17 +82,6 @@ defimpl Collectable, for: BitString do
   end
 end
 
-defimpl Collectable, for: Function do
-  def empty(function) do
-    function
-  end
-
-  def into(function) do
-    IO.write :stderr, "warning: passing a function as Collectable is deprecated\n#{Exception.format_stacktrace}"
-    {function, function}
-  end
-end
-
 defimpl Collectable, for: Map do
   def empty(_map) do
     %{}

lib/elixir/lib/enum.ex

@@ -341,7 +341,7 @@ defmodule Enum do
     {_, {acc, {buffer, i}}} =
       Enumerable.reduce(coll, {:cont, {[], {[], 0}}}, R.chunk(n, step, limit))
 
-    if nil?(pad) || i == 0 do
+    if is_nil(pad) || i == 0 do
       :lists.reverse(acc)
     else
       buffer = :lists.reverse(buffer) ++ take(pad, n - i)

lib/elixir/lib/exception.ex

@@ -618,7 +618,7 @@ defmodule UndefinedFunctionError do
   def message(%{function: function, module: module, arity: arity, self: self}) do
     if function do
       formatted = Exception.format_mfa module, function, arity
-      suffix = if self or nil?(module) or :code.is_loaded(module) do
+      suffix = if self or is_nil(module) or :code.is_loaded(module) do
         ""
       else
         " (module #{inspect module} is not available)"

lib/elixir/lib/integer.ex

@@ -5,23 +5,35 @@ defmodule Integer do
 
   import Bitwise
 
+  @doc false
+  defmacro odd?(n) do
+    quote do: (unquote(n) &&& 1) == 1
+  end
+
   @doc """
   Determines if an integer is odd.
 
   Returns `true` if `n` is an odd number, otherwise `false`.
-  Implemented as a macro so it is allowed in guard clauses.
+
+  Allowed in guard clauses.
   """
-  defmacro odd?(n) do
+  defmacro is_odd(n) do
     quote do: (unquote(n) &&& 1) == 1
   end
 
+  @doc false
+  defmacro even?(n) do
+    quote do: (unquote(n) &&& 1) == 0
+  end
+
   @doc """
   Determines if an integer is even.
 
   Returns `true` if `n` is an even number, otherwise `false`.
-  Implemented as a macro so it is allowed in guard clauses.
+
+  Allowed in guard clauses.
   """
-  defmacro even?(n) do
+  defmacro is_even(n) do
     quote do: (unquote(n) &&& 1) == 0
   end
 

lib/elixir/lib/kernel.ex

@@ -1875,20 +1875,25 @@ defmodule Kernel do
     quote do: List.Chars.to_char_list(unquote(arg))
   end
 
+  @doc false
+  defmacro nil?(x) do
+    quote do: unquote(x) == nil
+  end
+
   @doc """
   Checks if the given argument is nil or not.
   Allowed in guard clauses.
 
   ## Examples
 
-      iex> nil?(1)
+      iex> is_nil(1)
       false
 
-      iex> nil?(nil)
+      iex> is_nil(nil)
       true
 
   """
-  defmacro nil?(x) do
+  defmacro is_nil(x) do
     quote do: unquote(x) == nil
   end
 

lib/elixir/lib/macro/env.ex

@@ -105,9 +105,9 @@ defmodule Macro.Env do
   """
   def stacktrace(%{__struct__: Macro.Env} = env) do
     cond do
-      nil?(env.module) ->
+      is_nil(env.module) ->
         [{:elixir_compiler, :__FILE__, 1, relative_location(env)}]
-      nil?(env.function) ->
+      is_nil(env.function) ->
         [{env.module, :__MODULE__, 0, relative_location(env)}]
       true ->
         {name, arity} = env.function

lib/elixir/lib/module.ex

@@ -476,11 +476,6 @@ defmodule Module do
     :elixir_aliases.safe_concat([left, right])
   end
 
-  @doc false
-  def function(mod, fun, arity) do
-    :erlang.make_fun(mod, fun, arity)
-  end
-
   @doc """
   Attaches documentation to a given function or type. It expects
   the module the function/type belongs to, the line (a non negative
@@ -522,7 +517,7 @@ defmodule Module do
           line,
           kind,
           merge_signatures(old_sign, signature, 1),
-          if(nil?(doc), do: old_doc, else: doc)
+          if(is_nil(doc), do: old_doc, else: doc)
        })
         :ok
     end
@@ -896,7 +891,7 @@ defmodule Module do
   end
 
   @doc false
-  def get_attribute(module, key, warn) when is_atom(key) and (is_list(warn) or nil?(warn)) do
+  def get_attribute(module, key, warn) when is_atom(key) and (is_list(warn) or is_nil(warn)) do
     assert_not_compiled!(:get_attribute, module)
     table = data_table_for(module)
 

lib/elixir/lib/record.ex

@@ -4,7 +4,7 @@ defmodule Record do
 
   Records are simply tuples where the first element is an atom:
 
-      iex> Record.record? {User, "john", 27}
+      iex> Record.is_record {User, "john", 27}
       true
 
   This module provides conveniences for working with records at
@@ -56,6 +56,23 @@ defmodule Record do
     Macro.escape Record.Extractor.extract(name, opts)
   end
 
+  @doc false
+  defmacro record?(data, kind) do
+    case Macro.Env.in_guard?(__CALLER__) do
+      true ->
+        quote do
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
+            and :erlang.element(1, unquote(data)) == unquote(kind)
+        end
+      false ->
+        quote do
+          result = unquote(data)
+          is_tuple(result) and tuple_size(result) > 0
+            and :erlang.element(1, result) == unquote(kind)
+        end
+    end
+  end
+
   @doc """
   Checks if the given `data` is a record of `kind`.
 
@@ -64,11 +81,11 @@ defmodule Record do
   ## Examples
 
       iex> record = {User, "john", 27}
-      iex> Record.record?(record, User)
+      iex> Record.is_record(record, User)
       true
 
   """
-  defmacro record?(data, kind) do
+  defmacro is_record(data, kind) do
     case Macro.Env.in_guard?(__CALLER__) do
       true ->
         quote do
@@ -84,6 +101,23 @@ defmodule Record do
     end
   end
 
+  @doc false
+  defmacro record?(data) do
+    case Macro.Env.in_guard?(__CALLER__) do
+      true ->
+        quote do
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
+            and is_atom(:erlang.element(1, unquote(data)))
+        end
+      false ->
+        quote do
+          result = unquote(data)
+          is_tuple(result) and tuple_size(result) > 0
+            and is_atom(:erlang.element(1, result))
+        end
+    end
+  end
+
   @doc """
   Checks if the given `data` is a record.
 
@@ -92,14 +126,14 @@ defmodule Record do
   ## Examples
 
       iex> record = {User, "john", 27}
-      iex> Record.record?(record)
+      iex> Record.is_record(record)
       true
       iex> tuple = {}
-      iex> Record.record?(tuple)
+      iex> Record.is_record(tuple)
       false
 
   """
-  defmacro record?(data) do
+  defmacro is_record(data) do
     case Macro.Env.in_guard?(__CALLER__) do
       true ->
         quote do
@@ -319,7 +353,7 @@ defmodule Record do
   # Returns a keyword list of the record
   @doc false
   def __keyword__(atom, fields, record) do
-    if record?(record, atom) do
+    if is_record(record, atom) do
       [_tag|values] = Tuple.to_list(record)
       join_keyword(fields, values, [])
     else

lib/elixir/lib/stream.ex

@@ -162,7 +162,7 @@ defmodule Stream do
   end
 
   defp do_chunk(acc(h, {buffer, count} = old, t) = acc, n, pad, f1) do
-    if nil?(pad) || count == 0 do
+    if is_nil(pad) || count == 0 do
       {:cont, acc}
     else
       buffer = :lists.reverse(buffer) ++ Enum.take(pad, n - count)