Raise an error when Dict/Set doesn't support the target

Author: Devin Torres

lib/elixir/lib/dict.ex

@@ -73,6 +73,8 @@ defmodule Dict do
           elem(unquote(dict), 0)
         is_list(unquote(dict)) ->
           ListDict
+        true ->
+          unsupported_dict(unquote(dict))
       end
     end
   end
@@ -480,4 +482,8 @@ defmodule Dict do
   def to_list(dict) do
     target(dict).to_list(dict)
   end
+
+  defp unsupported_dict(dict) do
+    raise ArgumentError, message: "unsupported dict: #{inspect dict}"
+  end
 end

lib/elixir/lib/set.ex

@@ -38,8 +38,10 @@ defmodule Set do
 
   defmacrop target(set) do
     quote do
-      cond do
-        is_tuple(unquote(set)) -> HashSet
+      if is_tuple(unquote(set)) do
+        elem(unquote(set), 0)
+      else
+        unsupported_set(unquote(set))
       end
     end
   end
@@ -225,4 +227,7 @@ defmodule Set do
     target(set1).union(set1, set2)
   end
 
+  defp unsupported_set(set) do
+    raise ArgumentError, message: "unsupported set: #{inspect set}"
+  end
 end

lib/elixir/test/elixir/dict_test.exs

@@ -207,6 +207,21 @@ defmodule DictTest.Common do
         assert empty_dict == Dict.empty new_dict
       end
 
+      test :equal? do
+        dict1 = HashDict.new(a: 2, b: 3, f: 5, c: 123)
+        dict2 = ListDict.new(a: 2, b: 3, f: 5, c: 123)
+        assert Dict.equal?(dict1, dict2)
+
+        dict2 = Dict.put(dict2, :a, 3)
+        refute Dict.equal?(dict1, dict2)
+      end
+
+      test "unsupported dict" do
+        assert_raise ArgumentError, "unsupported dict: :bad_dict", fn ->
+          Dict.to_list :bad_dict
+        end
+      end
+
       defp empty_dict, do: unquote(module).new
 
       defp new_dict(list // [{"first_key", 1}, {"second_key", 2}]) do
@@ -216,15 +231,6 @@ defmodule DictTest.Common do
       defp new_dict(list, transform) do
         unquote(module).new list, transform
       end
-
-      test :equal? do
-        dict1 = HashDict.new(a: 2, b: 3, f: 5, c: 123)
-        dict2 = ListDict.new(a: 2, b: 3, f: 5, c: 123)
-        assert Dict.equal?(dict1, dict2)
-
-        dict2 = Dict.put(dict2, :a, 3)
-        refute Dict.equal?(dict1, dict2)
-      end
     end
   end
 end

lib/elixir/test/elixir/set_test.exs

@@ -5,22 +5,18 @@ defmodule SetTest.Common do
     quote location: :keep do
       use ExUnit.Case, async: true
 
-      def sets_equal(set1, set2) do
-        Set.equal?(set1, set2)
-      end
-
       test "a set removes duplicates" do
-        assert sets_equal(new_set([1, 1, 2, 3, 3, 3]), new_set([1, 2, 3]))
+        assert Set.equal?(new_set([1, 1, 2, 3, 3, 3]), new_set([1, 2, 3]))
       end
 
       test :delete do
         result = Set.delete(new_set([1, 2, 3]), 2)
-        assert sets_equal(result, new_set([1, 3]))
+        assert Set.equal?(result, new_set([1, 3]))
       end
 
       test :difference do
         result = Set.difference(new_set([1, 2, 3]), new_set([3]))
-        assert sets_equal(result, HashSet.new([1, 2]))
+        assert Set.equal?(result, HashSet.new([1, 2]))
       end
 
       test :disjoint? do
@@ -30,7 +26,7 @@ defmodule SetTest.Common do
 
       test :empty do
         result = Set.empty new_set([1, 2, 3])
-        assert sets_equal(result, new_set)
+        assert Set.equal?(result, new_set)
       end
 
       test :equal? do
@@ -39,7 +35,7 @@ defmodule SetTest.Common do
 
       test :intersection do
         result = Set.intersection(new_set([1, 2, 3]), new_set([2, 3, 4]))
-        assert sets_equal(result, new_set([2, 3]))
+        assert Set.equal?(result, new_set([2, 3]))
       end
 
       test :member? do
@@ -49,7 +45,7 @@ defmodule SetTest.Common do
 
       test :put do
         result = Set.put(new_set([1, 2]), 3)
-        assert sets_equal(result, new_set([1, 2, 3]))
+        assert Set.equal?(result, new_set([1, 2, 3]))
       end
 
       test :size do
@@ -67,13 +63,18 @@ defmodule SetTest.Common do
 
       test :union do
         result = Set.union(new_set([1, 2, 3]), new_set([2, 3, 4]))
-        assert sets_equal(result, new_set([1, 2, 3, 4]))
+        assert Set.equal?(result, new_set([1, 2, 3, 4]))
+      end
+
+      test "unsupported set" do
+        assert_raise ArgumentError, "unsupported set: :bad_set", fn ->
+          Set.to_list :bad_set
+        end
       end
 
       defp new_set(list // []) do
         unquote(module).new(list)
       end
-
     end
   end
 end