Type Map.replace/3 and Map.replace_lazy/3

Author: josevalim

lib/elixir/lib/module/types/apply.ex

@@ -251,6 +251,8 @@ defmodule Module.Types.Apply do
         {Map, :pop, [{[open_map(), term()], tuple([term(), open_map()])}]},
         {Map, :pop, [{[open_map(), term(), term()], tuple([term(), open_map()])}]},
         {Map, :pop!, [{[open_map(), term()], tuple([term(), open_map()])}]},
+        {Map, :replace, [{[open_map(), term(), term()], open_map()}]},
+        {Map, :replace_lazy, [{[open_map(), term(), fun(1)], open_map()}]},
         {Map, :update!, [{[open_map(), term(), fun(1)], open_map()}]},
         {:maps, :from_keys, [{[list(term()), term()], open_map()}]},
         {:maps, :find,
@@ -419,22 +421,22 @@ defmodule Module.Types.Apply do
     case map_update(map, @struct_key, not_set(), false, true) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
       :badmap -> {:error, badremote(Map, :from_struct, args_types)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, @struct_key, nil}}
+      {:error, _errors} -> {:error, {:badkeydomain, map, @struct_key, "raise"}}
     end
   end
 
   defp remote_apply(Map, :get, _info, [map, key] = args_types, stack) do
     case map_get(map, key) do
       {:ok, value} -> {:ok, return(union(value, @nil_atom), args_types, stack)}
-      :badmap -> {:error, badremote(:maps, :get, args_types)}
+      :badmap -> {:error, badremote(Map, :get, args_types)}
       :error -> {:error, {:badkeydomain, map, key, @nil_atom}}
     end
   end
 
   defp remote_apply(Map, :get, _info, [map, key, default] = args_types, stack) do
     case map_get(map, key) do
       {:ok, value} -> {:ok, return(union(value, default), args_types, stack)}
-      :badmap -> {:error, badremote(:maps, :get, args_types)}
+      :badmap -> {:error, badremote(Map, :get, args_types)}
       :error -> {:error, {:badkeydomain, map, key, default}}
     end
   end
@@ -444,7 +446,7 @@ defmodule Module.Types.Apply do
       {:ok, default} ->
         case map_get(map, key) do
           {:ok, value} -> {:ok, return(union(value, default), args_types, stack)}
-          :badmap -> {:error, badremote(:maps, :get, args_types)}
+          :badmap -> {:error, badremote(Map, :get_lazy, args_types)}
           :error -> {:error, {:badkeydomain, map, key, default}}
         end
 
@@ -477,36 +479,26 @@ defmodule Module.Types.Apply do
     case map_update(map, key, not_set(), true, false) do
       {value, descr, _errors} -> {:ok, return(tuple([value, descr]), args_types, stack)}
       :badmap -> {:error, badremote(Map, :pop!, args_types)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, "raise"}}
     end
   end
 
-  defp remote_apply(Map, :update!, _info, [map, key, fun] = args_types, stack) do
-    try do
-      {map, fun} =
-        case fun do
-          %{dynamic: fun} -> {dynamic(map), fun}
-          _ -> {map, fun}
-        end
-
-      fun_apply = fn arg_type ->
-        case fun_apply(fun, [arg_type]) do
-          {:ok, res} -> res
-          reason -> throw({:badapply, reason, [arg_type]})
-        end
-      end
-
-      map_update_fun(map, key, fun_apply, false, false)
-    catch
-      {:badapply, reason, args_types} ->
-        {:error, {:badapply, fun, args_types, reason}}
-    else
+  defp remote_apply(Map, :replace, _info, [map, key, value] = args_types, stack) do
+    case map_update(map, key, value, false, false) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
-      :badmap -> {:error, badremote(Map, :update!, args_types)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+      :badmap -> {:error, badremote(Map, :replace, args_types)}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, "do nothing"}}
     end
   end
 
+  defp remote_apply(Map, :replace_lazy, _info, args_types, stack) do
+    map_update_or_replace_lazy(:replace_lazy, args_types, stack, "do nothing")
+  end
+
+  defp remote_apply(Map, :update!, _info, args_types, stack) do
+    map_update_or_replace_lazy(:update!, args_types, stack, "raise")
+  end
+
   defp remote_apply(:maps, :find, _info, [key, map] = args_types, stack) do
     case map_get(map, key) do
       {_, value} ->
@@ -559,7 +551,7 @@ defmodule Module.Types.Apply do
     case map_get(map, key) do
       {:ok, value} -> {:ok, return(value, args_types, stack)}
       :badmap -> {:error, badremote(:maps, :get, args_types)}
-      :error -> {:error, {:badkeydomain, map, key, nil}}
+      :error -> {:error, {:badkeydomain, map, key, "raise"}}
     end
   end
 
@@ -574,15 +566,15 @@ defmodule Module.Types.Apply do
     case map_update(map, key, value, false, true) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
       :badmap -> {:error, badremote(:maps, :put, args_types)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, "raise"}}
     end
   end
 
   defp remote_apply(:maps, :remove, _info, [key, map] = args_types, stack) do
     case map_update(map, key, not_set(), false, true) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
       :badmap -> {:error, badremote(:maps, :remove, args_types)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, "raise"}}
     end
   end
 
@@ -611,7 +603,7 @@ defmodule Module.Types.Apply do
     case map_update(map, key, value, false, false) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
       :badmap -> {:error, badremote(:maps, :update, args_types)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, "raise"}}
     end
   end
 
@@ -975,6 +967,34 @@ defmodule Module.Types.Apply do
     end
   end
 
+  ## Map helpers
+
+  def map_update_or_replace_lazy(name, [map, key, fun] = args_types, stack, error) do
+    try do
+      {map, fun} =
+        case fun do
+          %{dynamic: fun} -> {dynamic(map), fun}
+          _ -> {map, fun}
+        end
+
+      fun_apply = fn arg_type ->
+        case fun_apply(fun, [arg_type]) do
+          {:ok, res} -> res
+          reason -> throw({:badapply, reason, [arg_type]})
+        end
+      end
+
+      map_update_fun(map, key, fun_apply, false, false)
+    catch
+      {:badapply, reason, args_types} ->
+        {:error, {:badapply, fun, args_types, reason}}
+    else
+      {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
+      :badmap -> {:error, badremote(Map, name, args_types)}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, error}}
+    end
+  end
+
   ## Application helpers
 
   defp return(type, args_types, stack) do
@@ -1257,10 +1277,10 @@ defmodule Module.Types.Apply do
 
               #{to_quoted_string(key) |> indent(4)}
 
-          therefore this function will always #{if error do
-            "return #{to_quoted_string(error)}"
+          therefore this function will always #{if is_binary(error) do
+            error
           else
-            "raise"
+            "return #{to_quoted_string(error)}"
           end}
           """,
           format_traces(traces)

lib/elixir/test/elixir/module/types/map_test.exs

@@ -756,6 +756,140 @@ defmodule Module.Types.MapTest do
     end
   end
 
+  describe "Map.replace/3" do
+    test "checking" do
+      assert typecheck!(Map.replace(%{key: 123}, :key, :value)) ==
+               closed_map(key: atom([:value]))
+
+      assert typecheck!([x], Map.replace(x, :key, :value)) ==
+               dynamic(open_map(key: atom([:value])))
+
+      # If one of them succeeds, we are still fine!
+      assert typecheck!(
+               [condition?],
+               Map.replace(%{foo: 123}, if(condition?, do: :foo, else: :bar), "123")
+             ) == closed_map(foo: binary())
+
+      assert typecheck!([x], Map.replace(x, 123, 456)) == dynamic(open_map())
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.replace(x, :key, :value)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!(Map.replace(%{}, :key, :value)) =~
+               """
+               incompatible types given to Map.replace/3:
+
+                   Map.replace(%{}, :key, :value)
+
+               the map:
+
+                   empty_map()
+
+               does not have all required keys:
+
+                   :key
+
+               therefore this function will always do nothing
+               """
+    end
+  end
+
+  describe "Map.replace_lazy/3" do
+    test "checking" do
+      assert typecheck!(Map.replace_lazy(%{key: 123}, :key, fn _ -> :value end)) ==
+               dynamic(closed_map(key: atom([:value])))
+
+      assert typecheck!([x], Map.replace_lazy(x, :key, fn _ -> :value end)) ==
+               dynamic(open_map(key: atom([:value])))
+
+      # If one of them succeeds, we are still fine!
+      assert typecheck!(
+               [condition?],
+               Map.replace_lazy(%{foo: 123}, if(condition?, do: :foo, else: :bar), fn _ ->
+                 "123"
+               end)
+             ) == dynamic(closed_map(foo: binary()))
+
+      # Both succeed but different clauses
+      assert typecheck!(
+               [condition?],
+               Map.replace_lazy(
+                 %{key1: :foo, key2: :bar},
+                 if(condition?, do: :key1, else: :key2),
+                 fn
+                   :foo -> 123
+                   :bar -> 123.0
+                 end
+               )
+             ) ==
+               dynamic(
+                 union(
+                   closed_map(key1: atom([:foo]), key2: float()),
+                   closed_map(key1: integer(), key2: atom([:bar]))
+                 )
+               )
+
+      assert typecheck!([x], Map.replace_lazy(x, 123, fn _ -> 456 end)) == dynamic(open_map())
+
+      assert typecheck!([], Map.replace_lazy(%{123 => 456}, 123, fn x -> x * 1.0 end)) ==
+               dynamic(closed_map([{domain_key(:integer), union(integer(), float())}]))
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.replace_lazy(x, :key, fn _ -> :value end)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!(Map.replace_lazy(%{}, :key, fn _ -> :value end)) =~
+               """
+               incompatible types given to Map.replace_lazy/3:
+
+                   Map.replace_lazy(%{}, :key, fn _ -> :value end)
+
+               the map:
+
+                   empty_map()
+
+               does not have all required keys:
+
+                   :key
+
+               therefore this function will always do nothing
+               """
+
+      assert typeerror!(Map.replace_lazy(%{key: :foo}, :key, fn :bar -> :value end))
+             |> strip_ansi() =~
+               """
+               incompatible types given on function call within Map.replace_lazy/3:
+
+                   Map.replace_lazy(%{key: :foo}, :key, fn :bar -> :value end)
+
+               given types:
+
+                   dynamic(:foo)
+
+               but function has type:
+
+                   (:bar -> dynamic(:value))
+               """
+    end
+  end
+
   describe "Map.replace!/3" do
     test "checking" do
       assert typecheck!(Map.replace!(%{key: 123}, :key, :value)) ==