Improve contracts for Set

Similar to how it has been done to Dict, functions in the
Set are polymorphic but Set implementations should not provide
polymorphic functions.

This reduces the duplication inside each set implementation
and provides both strict and polymorphic interfaces.

Author: José Valim

lib/elixir/lib/dict.ex

@@ -264,7 +264,7 @@ defmodule Dict do
   the functions in entries in `b` have higher precedence unless a
   function is given to resolve conflicts.
 
-  Notice this function is polymorphic as it can merge dicts of any
+  Notice this function is polymorphic as it merges dicts of any
   type. Each dict implementation also provides a `merge` function,
   but they can only merge dicts of the same type.
 
@@ -286,15 +286,15 @@ defmodule Dict do
 
   """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(a, b, fun // fn(_k, _v1, v2) -> v2 end) do
-    a_target = target(a)
-    b_target = target(b)
+  def merge(dict1, dict2, fun // fn(_k, _v1, v2) -> v2 end) do
+    target1 = target(dict1)
+    target2 = target(dict2)
 
-    if a_target == b_target do
-      a_target.merge(a, b, fun)
+    if target1 == target2 do
+      target1.merge(dict1, dict2, fun)
     else
-      b_target.reduce(b, { :cont, a }, fn({ k, v }, acc) ->
-        { :cont, a_target.update(acc, k, v, fn(other) -> fun.(k, other, v) end) }
+      target2.reduce(dict2, { :cont, dict1 }, fn({ k, v }, acc) ->
+        { :cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end) }
       end) |> elem(1)
     end
   end
@@ -455,7 +455,7 @@ defmodule Dict do
   @doc """
   Check if two dicts are equal using `===`.
 
-  Notice this function is polymorphic as it can merge dicts of any
+  Notice this function is polymorphic as it compares dicts of any
   type. Each dict implementation also provides an `equal?` function,
   but they can only compare dicts of the same type.
 
@@ -473,17 +473,17 @@ defmodule Dict do
 
   """
   @spec equal?(t, t) :: boolean
-  def equal?(a, b) do
-    a_target = target(a)
-    b_target = target(b)
+  def equal?(dict1, dict2) do
+    target1 = target(dict1)
+    target2 = target(dict2)
 
     cond do
-      a_target == b_target ->
-        a_target.equal?(a, b)
+      target1 == target2 ->
+        target1.equal?(dict1, dict2)
 
-      a_target.size(a) == b_target.size(b) ->
-        a_target.reduce(a, { :cont, true }, fn({ k, v }, _acc) ->
-          case b_target.fetch(b, k) do
+      target1.size(dict1) == target2.size(dict2) ->
+        target1.reduce(dict1, { :cont, true }, fn({ k, v }, _acc) ->
+          case target2.fetch(dict2, k) do
             { :ok, ^v } -> { :cont, true }
             _           -> { :halt, false }
           end

lib/elixir/lib/hash_set.ex

@@ -72,32 +72,14 @@ defmodule HashSet do
     set_fold set2, set1, fn v, acc -> put(acc, v) end
   end
 
-  def union(trie() = set1, set2) do
-    set_fold set1, set2, fn v, acc -> put(acc, v) end
-  end
-
   def intersection(trie() = set1, trie() = set2) do
     set_fold set1, trie(), fn v, acc ->
       if member?(set2, v), do: put(acc, v), else: acc
     end
   end
 
-  def intersection(trie() = set1, set2) do
-    set_fold set1, trie(), fn v, acc ->
-      if Set.member?(set2, v), do: put(acc, v), else: acc
-    end
-  end
-
   def difference(trie() = set1, trie() = set2) do
-    set_fold set1, trie(), fn v, acc ->
-      if member?(set2, v), do: acc, else: put(acc, v)
-    end
-  end
-
-  def difference(trie() = set1, set2) do
-    set_fold set1, trie(), fn v, acc ->
-      if Set.member?(set2, v), do: acc, else: put(acc, v)
-    end
+    set_fold set2, set1, fn v, acc -> delete(acc, v) end
   end
 
   def to_list(set) do
@@ -120,16 +102,7 @@ defmodule HashSet do
     end) |> elem(1)
   end
 
-  def subset?(trie() = set1, set2) do
-    reduce(set1, { :cont, true }, fn member, acc ->
-      case Set.member?(set2, member) do
-        true -> { :cont, acc }
-        _    -> { :halt, false }
-      end
-    end) |> elem(1)
-  end
-
-  def disjoint?(set1, set2) do
+  def disjoint?(trie() = set1, trie() = set2) do
     reduce(set2, { :cont, true }, fn member, acc ->
       case member?(set1, member) do
         false -> { :cont, acc }
@@ -147,14 +120,14 @@ defmodule HashSet do
   end
 
   def put(trie(root: root, size: size), term) do
-    { root, counter } = do_put(root, term, key_hash(term))
+    {root, counter} = do_put(root, term, key_hash(term))
     trie(root: root, size: size + counter)
   end
 
   def delete(trie(root: root, size: size) = set, term) do
     case do_delete(root, term, key_hash(term)) do
-      { :ok, root } -> trie(root: root, size: size - 1)
-      :error        -> set
+      {:ok, root} -> trie(root: root, size: size - 1)
+      :error      -> set
     end
   end
 

lib/elixir/lib/set.ex

@@ -49,6 +49,7 @@ defmodule Set do
   defcallback intersection(t, t) :: t
   defcallback member?(t, value) :: boolean
   defcallback put(t, value) :: t
+  defcallback reduce(t, Enumerable.acc, Enumerable.reducer) :: Enumerable.result
   defcallback size(t) :: non_neg_integer
   defcallback subset?(t, t) :: boolean
   defcallback to_list(t) :: list()
@@ -85,6 +86,10 @@ defmodule Set do
   @doc """
   Returns a set that is `set1` without the members of `set2`.
 
+  Notice this function is polymorphic as it calculates the difference
+  for of any type. Each set implementation also provides a `difference`
+  function, but they can only work with sets of the same type.
+
   ## Examples
 
       iex> Set.difference(HashSet.new([1,2]), HashSet.new([2,3,4])) |> Enum.sort
@@ -93,12 +98,25 @@ defmodule Set do
   """
   @spec difference(t, t) :: t
   def difference(set1, set2) do
-    target(set1).difference(set1, set2)
+    target1 = target(set1)
+    target2 = target(set2)
+
+    if target1 == target2 do
+      target1.difference(set1, set2)
+    else
+      target2.reduce set2, { :cont, set1 }, fn v, acc ->
+        { :cont, target1.delete(acc, v) }
+      end |> elem(1)
+    end
   end
 
   @doc """
   Checks if `set1` and `set2` have no members in common.
 
+  Notice this function is polymorphic as it checks for disjoint sets of
+  any type. Each set implementation also provides a `disjoint?` function,
+  but they can only work with sets of the same type.
+
   ## Examples
 
       iex> Set.disjoint?(HashSet.new([1, 2]), HashSet.new([3, 4]))
@@ -109,7 +127,19 @@ defmodule Set do
   """
   @spec disjoint?(t, t) :: boolean
   def disjoint?(set1, set2) do
-    target(set1).disjoint?(set1, set2)
+    target1 = target(set1)
+    target2 = target(set2)
+
+    if target1 == target2 do
+      target1.disjoint?(set1, set2)
+    else
+      target2.reduce(set2, { :cont, true }, fn member, acc ->
+        case target1.member?(set1, member) do
+          false -> { :cont, acc }
+          _     -> { :halt, false }
+        end
+      end) |> elem(1)
+    end
   end
 
   @doc """
@@ -121,7 +151,11 @@ defmodule Set do
   end
 
   @doc """
-  Checks if `set1` and `set2` are equal.
+  Check if two sets are equal using `===`.
+
+  Notice this function is polymorphic as it compares sets of
+  any type. Each set implementation also provides an `equal?`
+  function, but they can only work with sets of the same type.
 
   ## Examples
 
@@ -134,12 +168,28 @@ defmodule Set do
   """
   @spec equal?(t, t) :: boolean
   def equal?(set1, set2) do
-    target(set1).equal?(set1, set2)
+    target1 = target(set1)
+    target2 = target(set2)
+
+    cond do
+      target1 == target2 ->
+        target1.equal?(set1, set2)
+
+      target1.size(set1) == target2.size(set2) ->
+        do_subset?(target1, target2, set1, set2)
+
+      true ->
+        false
+    end
   end
 
   @doc """
   Returns a set containing only members in common between `set1` and `set2`.
 
+  Notice this function is polymorphic as it calculates the intersection of
+  any type. Each set implementation also provides a `intersection` function,
+  but they can only work with sets of the same type.
+
   ## Examples
 
       iex> Set.intersection(HashSet.new([1,2]), HashSet.new([2,3,4])) |> Enum.sort
@@ -151,7 +201,16 @@ defmodule Set do
   """
   @spec intersection(t, t) :: t
   def intersection(set1, set2) do
-    target(set1).intersection(set1, set2)
+    target1 = target(set1)
+    target2 = target(set2)
+
+    if target1 == target2 do
+      target1.intersection(set1, set2)
+    else
+      target1.reduce set1, { :cont, target1.empty(set1) }, fn v, acc ->
+        { :cont, if(target2.member?(set2, v), do: target1.put(acc, v), else: acc) }
+      end |> elem(1)
+    end
   end
 
   @doc """
@@ -205,6 +264,10 @@ defmodule Set do
   @doc """
   Checks if `set1`'s members are all contained in `set2`.
 
+  Notice this function is polymorphic as it checks the subset for
+  any type. Each set implementation also provides a `subset?` function,
+  but they can only work with sets of the same type.
+
   ## Examples
 
       iex> Set.subset?(HashSet.new([1, 2]), HashSet.new([1, 2, 3]))
@@ -214,7 +277,14 @@ defmodule Set do
   """
   @spec subset?(t, t) :: boolean
   def subset?(set1, set2) do
-    target(set1).subset?(set1, set2)
+    target1 = target(set1)
+    target2 = target(set2)
+
+    if target1 == target2 do
+      target1.subset?(set1, set2)
+    else
+      do_subset?(target1, target2, set1, set2)
+    end
   end
 
   @doc """
@@ -234,6 +304,10 @@ defmodule Set do
   @doc """
   Returns a set containing all members of `set1` and `set2`.
 
+  Notice this function is polymorphic as it calculates the union of
+  any type. Each set implementation also provides a `union` function,
+  but they can only work with sets of the same type.
+
   ## Examples
 
       iex> Set.union(HashSet.new([1,2]), HashSet.new([2,3,4])) |> Enum.sort
@@ -242,7 +316,25 @@ defmodule Set do
   """
   @spec union(t, t) :: t
   def union(set1, set2) do
-    target(set1).union(set1, set2)
+    target1 = target(set1)
+    target2 = target(set2)
+
+    if target1 == target2 do
+      target1.union(set1, set2)
+    else
+      target2.reduce set2, { :cont, set1 }, fn v, acc ->
+        { :cont, target1.put(acc, v) }
+      end |> elem(1)
+    end
+  end
+
+  defp do_subset?(target1, target2, set1, set2) do
+    target1.reduce(set1, { :cont, true }, fn member, acc ->
+      case target2.member?(set2, member) do
+        true -> { :cont, acc }
+        _    -> { :halt, false }
+      end
+    end) |> elem(1)
   end
 
   defp unsupported_set(set) do