Ensure Enum.member? uses match (===)

Author: José Valim

lib/elixir/lib/enum.ex

@@ -38,6 +38,7 @@ defprotocol Enumerable do
 
   @doc """
   The function is used to check if a value exists within the collection.
+  Membership should be tested with the match (`===`) operator.
   """
   def member?(collection, value)
 
@@ -87,6 +88,10 @@ defmodule Enum do
   @doc """
   Checks if `value` exists within the `collection`.
 
+  Membership is tested with the match (`===`) operator although
+  enumerables like ranges may include floats inside the given
+  range.
+
   ## Examples
 
       iex> Enum.member?(1..10, 5)
@@ -1850,8 +1855,9 @@ defimpl Enumerable, for: Function do
   end
 
   def member?(function, value) do
-    function.(false, fn(entry, _) ->
-      if entry === value, do: throw(:function_member?), else: false
+    function.(false, fn
+      ^value, _ -> throw(:function_member?)
+      _, _ -> false
     end)
   catch
     :function_member? -> true

lib/elixir/lib/range.ex

@@ -17,15 +17,15 @@ defprotocol Range.Iterator do
 end
 
 defimpl Enumerable, for: Range do
-  def reduce(Range[first: first] = range, acc, fun) do
+  def reduce(first .. _ = range, acc, fun) do
     Range.Iterator.reduce(first, range, acc, fun)
   end
 
-  def member?(Range[first: first, last: last], value) do
-    value in first..last
+  def member?(first .. last, value) do
+    first <= value and value <= last
   end
 
-  def count(Range[first: first] = range) do
+  def count(first .. _ = range) do
     Range.Iterator.count(first, range)
   end
 end

lib/elixir/src/elixir_macros.erl

@@ -233,13 +233,13 @@ translate_in(Meta, Left, Right, S) ->
     { cons, _, _, _ } ->
       [H|T] = elixir_utils:cons_to_list(TRight),
       Expr = lists:foldr(fun(X, Acc) ->
-        { op, Line, 'orelse', { op, Line, '==', Var, X }, Acc }
-      end, { op, Line, '==', Var, H }, T),
+        { op, Line, 'orelse', { op, Line, '=:=', Var, X }, Acc }
+      end, { op, Line, '=:=', Var, H }, T),
       { Cache, Expr };
     { string, _, [H|T] } ->
       Expr = lists:foldl(fun(X, Acc) ->
-        { op, Line, 'orelse', { op, Line, '==', Var, { integer, Line, X } }, Acc }
-      end, { op, Line, '==', Var, { integer, Line, H } }, T),
+        { op, Line, 'orelse', { op, Line, '=:=', Var, { integer, Line, X } }, Acc }
+      end, { op, Line, '=:=', Var, { integer, Line, H } }, T),
       { Cache, Expr };
     { tuple, _, [{ atom, _, 'Elixir.Range' }, Start, End] } ->
       Expr = case { Start, End } of

lib/elixir/test/elixir/dict_test.exs

@@ -327,6 +327,13 @@ defmodule DictTest.Common do
         refute Dict.equal?(dict1, dict2)
       end
 
+      test :enum_member do
+        assert Enum.member?(new_dict([{1,1}]), { 1, 1 })
+        refute Enum.member?(new_dict([{1,1}]), { 1.0, 1 })
+        refute Enum.member?(new_dict([{1,1}]), { 1, 1.0 })
+        refute Enum.member?(new_dict([{1,1}]), { 1.0, 1.0 })
+      end
+
       test "unsupported dict" do
         assert_raise ArgumentError, "unsupported dict: :bad_dict", fn ->
           Dict.to_list :bad_dict

lib/elixir/test/elixir/kernel/case_test.exs

@@ -37,6 +37,10 @@ defmodule Kernel.CaseTest do
     assert not y in [1, 2, 3], "not in assertion"
   end
 
+  test :in_with_match do
+    refute 1.0 in [1, 2, 3], "not in assertion"
+  end
+
   defp get_case do
     case internal do
       :invalid ->

lib/elixir/test/elixir/range_test.exs

@@ -39,6 +39,7 @@ defmodule RangeTest do
     refute Enum.empty?(1..1)
 
     assert Enum.member?(1..3, 2)
+
     refute Enum.member?(1..3, 0)
     refute Enum.member?(1..3, 4)
     refute Enum.member?(3..1, 0)

lib/elixir/test/elixir/set_test.exs

@@ -98,6 +98,11 @@ defmodule SetTest.Common do
         assert Set.size(Set.union(int_set, new_set([1.0]))) == 4
       end
 
+      test :enum_member do
+        assert Enum.member?(int_set, 1)
+        refute Enum.member?(int_set, 1.0)
+      end
+
       test "unsupported set" do
         assert_raise ArgumentError, "unsupported set: :bad_set", fn ->
           Set.to_list :bad_set