Impose === as the operator in the Set API

Author: José Valim

lib/elixir/lib/hash_set.ex

@@ -38,7 +38,8 @@ defmodule HashSet do
   import Bitwise
 
   @compile :inline_list_funcs
-  @compile { :inline, bucket_hash: 1, bucket_index: 1, bucket_nth_index: 2, bucket_next: 1 }
+  @compile { :inline, bucket_hash: 1, bucket_index: 1, bucket_nth_index: 2,
+                      bucket_next: 1, bucket_member?: 2 }
 
   @doc """
   Creates a new empty set.
@@ -188,11 +189,11 @@ defmodule HashSet do
   end
 
   defp set_member?(ordered(bucket: bucket), member) do
-    :lists.member(member, bucket)
+    bucket_member?(member, bucket)
   end
 
   defp set_member?(trie(root: root, depth: depth), member) do
-    :lists.member(member, node_bucket(root, depth, bucket_hash(member)))
+    bucket_member?(member, node_bucket(root, depth, bucket_hash(member)))
   end
 
   defp set_delete(ordered(bucket: bucket, size: size) = set, member) do
@@ -260,6 +261,10 @@ defmodule HashSet do
 
   ## Bucket helpers
 
+  defp bucket_member?(k, [k|_]), do: true
+  defp bucket_member?(k, [_|t]), do: bucket_member?(k, t)
+  defp bucket_member?(_k, []),   do: false
+
   defp bucket_filter([e|bucket], fun, acc, count) do
     case fun.(e) do
       true  -> bucket_filter(bucket, fun, [e|acc], count)
@@ -476,13 +481,6 @@ defmodule HashSet do
   defp each_contract(acc, [m|bucket]), do: [m|each_contract(acc, bucket)]
   defp each_contract([], bucket), do: bucket
   defp each_contract(acc, []), do: acc
-
-  @doc false
-  def inspect_depth(trie(depth: d)), do: d
-  @doc false
-  def inspect_contract(trie(contract_on: c)), do: c
-  @doc false
-  def inspect_expand(trie(expand_on: e)), do: e
 end
 
 defimpl Enumerable, for: HashSet do

lib/elixir/lib/set.ex

@@ -15,6 +15,21 @@ defmodule Set do
   For simplicity's sake, in the examples below every time
   `new` is used, it implies one of the module-specific
   calls like above.
+
+  ## Protocols
+
+  Sets are required to implement the `Enumerable` protocol,
+  allowing one to write:
+
+      Enum.each(set, fn k ->
+        IO.inspect k
+      end)
+
+  ## Match
+
+  Sets are required to implement all operations
+  using the match (`===`) operator. Any deviation from
+  this behaviour should be avoided and explicitly documented.
   """
 
   use Behaviour

lib/elixir/test/elixir/hash_set_test.exs

@@ -40,10 +40,8 @@ defmodule HashSetTest do
     diff = HashSet.difference(filled_set(9000), filled_set(9000))
     assert HashSet.equal?(diff, HashSet.new([]))
 
-    #Ensure the trie has correctly resized
-    assert HashSet.inspect_depth(diff) == 0
-    assert HashSet.inspect_contract(diff) ==  2
-    assert HashSet.inspect_expand(diff) == 80
+    # Ensure the trie has correctly resized
+    assert { HashSet, 0, 0, 80, 2, _ } = diff
   end
 
   test "member? with ordered sets"  do

lib/elixir/test/elixir/set_test.exs

@@ -14,11 +14,21 @@ defmodule SetTest.Common do
         assert Set.equal?(result, new_set([1, 3]))
       end
 
+      test :delete_with_match do
+        refute Set.member?(Set.delete(int_set, 1), 1)
+        assert Set.member?(Set.delete(int_set, 1.0), 1)
+      end
+
       test :difference do
         result = Set.difference(new_set([1, 2, 3]), new_set([3]))
         assert Set.equal?(result, HashSet.new([1, 2]))
       end
 
+      test :difference_with_match do
+        refute Set.member?(Set.difference(int_set, new_set([1])), 1)
+        assert Set.member?(Set.difference(int_set, new_set([1.0])), 1)
+      end
+
       test :disjoint? do
         assert Set.disjoint?(new_set([1, 2, 3]), new_set([4, 5 ,6])) == true
         assert Set.disjoint?(new_set([1, 2, 3]), new_set([3, 4 ,5])) == false
@@ -30,31 +40,48 @@ defmodule SetTest.Common do
       end
 
       test :equal? do
-        assert Set.equal?(new_set([1, 2, 3]), new_set([3, 2, 1])) == true
+        assert Set.equal?(new_set([1, 2, 3]), new_set([3, 2, 1]))
+        refute Set.equal?(new_set([1, 2, 3]), new_set([3.0, 2.0, 1.0]))
       end
 
       test :intersection do
         result = Set.intersection(new_set([1, 2, 3]), new_set([2, 3, 4]))
         assert Set.equal?(result, new_set([2, 3]))
       end
 
+      test :intersection_with_match do
+        assert Set.member?(Set.intersection(int_set, new_set([1])), 1)
+        refute Set.member?(Set.intersection(int_set, new_set([1.0])), 1)
+      end
+
       test :member? do
-        assert Set.member?(new_set([1, 2, 3]), 2) == true
-        assert Set.member?(new_set([1, 2, 3]), 4) == false
+        assert Set.member?(new_set([1, 2, 3]), 2)
+        refute Set.member?(new_set([1, 2, 3]), 4)
+        refute Set.member?(new_set([1, 2, 3]), 1.0)
       end
 
       test :put do
         result = Set.put(new_set([1, 2]), 3)
         assert Set.equal?(result, new_set([1, 2, 3]))
       end
 
+      test :put_with_match do
+        assert Set.size(Set.put(int_set, 1)) == 3
+        assert Set.size(Set.put(int_set, 1.0)) == 4
+      end
+
       test :size do
         assert Set.size(new_set([1, 2, 3])) == 3
       end
 
       test :subset? do
-        assert Set.subset?(new_set([1, 2]), new_set([1, 2, 3])) == true
-        assert Set.subset?(new_set([1, 2, 3]), new_set([1, 2])) == false
+        assert Set.subset?(new_set([1, 2]), new_set([1, 2, 3]))
+        refute Set.subset?(new_set([1, 2, 3]), new_set([1, 2]))
+      end
+
+      test :subset_with_match? do
+        assert Set.subset?(new_set([1]), int_set)
+        refute Set.subset?(new_set([1.0]), int_set)
       end
 
       test :to_list do
@@ -66,6 +93,11 @@ defmodule SetTest.Common do
         assert Set.equal?(result, new_set([1, 2, 3, 4]))
       end
 
+      test :union_with_match do
+        assert Set.size(Set.union(int_set, new_set([1]))) == 3
+        assert Set.size(Set.union(int_set, new_set([1.0]))) == 4
+      end
+
       test "unsupported set" do
         assert_raise ArgumentError, "unsupported set: :bad_set", fn ->
           Set.to_list :bad_set
@@ -75,6 +107,10 @@ defmodule SetTest.Common do
       defp new_set(list // []) do
         unquote(module).new(list)
       end
+
+      defp int_set() do
+        unquote(module).new([1,2,3])
+      end
     end
   end
 end