Add Map.replace_lazy/3 and Keyword.replace_lazy/3 (#11474)

Author: maco

lib/elixir/lib/keyword.ex

@@ -867,6 +867,40 @@ defmodule Keyword do
     raise KeyError, key: key, term: original
   end
 
+  @doc """
+  Replaces the value under `key` using the given function only if
+  `key` already exists in `keywords`.
+
+  In comparison to `replace/3`, this can be useful when it's expensive to calculate the value.
+
+  If `key` does not exist, the original keyword list is returned unchanged.
+
+  ## Examples
+
+      iex> Keyword.replace_lazy([{:a, 1}, {:b, 2}], :a, fn v -> v * 4 end)
+      [{:a, 4}, {:b, 2}]
+
+      iex> Keyword.replace_lazy([{:a, 1}, {:b, 2}], :c, fn v -> v * 4 end)
+      [{:a, 1}, {:b, 2}]
+
+  """
+  @doc since: "1.14.0"
+  @spec replace_lazy(t, key, (existing_value :: value -> new_value :: value)) :: t
+  def replace_lazy(keywords, key, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 1) do
+    do_replace_lazy(keywords, key, fun)
+  end
+
+  defp do_replace_lazy([{key, value} | keywords], key, fun) do
+    [{key, fun.(value)} | delete(keywords, key)]
+  end
+
+  defp do_replace_lazy([{_, _} = e | keywords], key, fun) do
+    [e | replace_lazy(keywords, key, fun)]
+  end
+
+  defp do_replace_lazy([], _key, _value), do: []
+
   @doc """
   Checks if two keywords are equal.
 

lib/elixir/lib/map.ex

@@ -371,6 +371,32 @@ defmodule Map do
     :maps.update(key, value, map)
   end
 
+  @doc """
+  Replaces the value under `key` using the given function only if
+  `key` already exists in `map`.
+
+  In comparison to `replace/3`, this can be useful when it's expensive to calculate the value.
+
+  If `key` does not exist, the original map is returned unchanged.
+
+  ## Examples
+
+      iex> Map.replace_lazy(%{a: 1, b: 2}, :a, fn v -> v * 4 end)
+      %{a: 4, b: 2}
+
+      iex> Map.replace_lazy(%{a: 1, b: 2}, :c, fn v -> v * 4 end)
+      %{a: 1, b: 2}
+
+  """
+  @doc since: "1.14.0"
+  @spec replace_lazy(map, key, (existing_value :: value -> new_value :: value)) :: map
+  def replace_lazy(map, key, fun) when is_map(map) and is_function(fun, 1) do
+    case map do
+      %{^key => val} -> %{map | key => fun.(val)}
+      %{} -> map
+    end
+  end
+
   @doc """
   Evaluates `fun` and puts the result under `key`
   in `map` unless `key` is already present.