Bring back filter/reject on Map and Keyword

They are already being used in projects, which
means it is too late for a deprecation. The docs
instead discuss when to use them.

Author: josevalim

lib/elixir/lib/keyword.ex

@@ -1317,16 +1317,61 @@ defmodule Keyword do
     length(keywords)
   end
 
-  @doc false
-  @deprecated "Use Enum.filter/2 instead"
-  def filter(keywords, fun) when is_list(keywords) do
-    Enum.filter(keywords, fun)
+  @doc """
+  Returns a keyword list containing only the entries from `keywords`
+  for which the function `fun` returns a truthy value.
+
+  See also `reject/2` which discards all entries where the function
+  returns a truthy value.
+
+  ## Examples
+
+      iex> Keyword.filter([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
+      [one: 1, three: 3]
+
+  """
+  @doc since: "1.13.0"
+  @spec filter(t, ({key, value} -> as_boolean(term))) :: t
+  def filter(keywords, fun) when is_list(keywords) and is_function(fun, 1) do
+    do_filter(keywords, fun)
   end
 
-  @doc false
-  @deprecated "Use Keyword.new/2 instead"
-  def reject(keywords, fun) when is_list(keywords) do
-    Enum.reject(keywords, fun)
+  defp do_filter([], _fun), do: []
+
+  defp do_filter([{_, _} = entry | entries], fun) do
+    if fun.(entry) do
+      [entry | do_filter(entries, fun)]
+    else
+      do_filter(entries, fun)
+    end
+  end
+
+  @doc """
+  Returns a keyword list excluding the entries from `keywords`
+  for which the function `fun` returns a truthy value.
+
+  See also `filter/2`.
+
+  ## Examples
+
+      iex> Keyword.reject([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
+      [two: 2]
+
+  """
+  @doc since: "1.13.0"
+  @spec reject(t, ({key, value} -> as_boolean(term))) :: t
+  def reject(keywords, fun) when is_list(keywords) and is_function(fun, 1) do
+    do_reject(keywords, fun)
+  end
+
+  defp do_reject([], _fun), do: []
+
+  defp do_reject([{_, _} = entry | entries], fun) do
+    if fun.(entry) do
+      do_reject(entries, fun)
+    else
+      [entry | do_reject(entries, fun)]
+    end
   end
 
   @doc false

lib/elixir/lib/map.ex

@@ -214,24 +214,7 @@ defmodule Map do
 
   """
   @spec new(Enumerable.t(), (term -> {key, value})) :: map
-  def new(enumerable, transform)
-  def new(%_{} = enumerable, transform), do: new_from_enum(enumerable, transform)
-  def new(%{} = map, transform), do: new_from_map(map, transform)
-  def new(enumerable, transform), do: new_from_enum(enumerable, transform)
-
-  defp new_from_map(map, transform) when is_function(transform, 1) do
-    iter = :maps.iterator(map)
-    next = :maps.next(iter)
-    :maps.from_list(do_map(next, transform))
-  end
-
-  defp do_map(:none, _fun), do: []
-
-  defp do_map({key, value, iter}, transform) do
-    [transform.({key, value}) | do_map(:maps.next(iter), transform)]
-  end
-
-  defp new_from_enum(enumerable, transform) when is_function(transform, 1) do
+  def new(enumerable, transform) when is_function(transform, 1) do
     enumerable
     |> Enum.map(transform)
     |> :maps.from_list()
@@ -989,16 +972,73 @@ defmodule Map do
     map_size(map)
   end
 
-  @doc false
-  @deprecated "Use Enum.filter/2 instead"
-  def filter(map, fun) when is_map(map) do
-    Enum.filter(map, fun) |> :maps.from_list()
+  @doc """
+  Returns a map containing only those pairs from `map`
+  for which `fun` returns a truthy value.
+
+  `fun` receives the key and value of each of the
+  elements in the map as a key-value pair.
+
+  See also `reject/2` which discards all elements where the
+  function returns a truthy value.
+
+  > Note: if you find yourself doing multiple calls to `Map.filter/2`
+  > and `Map.reject/2` in a pipeline, it is likely more efficient
+  > to use `Enum.map/2` and `Enum.filter/2` instead and convert to
+  > a map at the end using `Map.new/1`.
+
+  ## Examples
+
+      iex> Map.filter(%{one: 1, two: 2, three: 3}, fn {_key, val} -> rem(val, 2) == 1 end)
+      %{one: 1, three: 3}
+
+  """
+  @doc since: "1.13.0"
+  @spec filter(map, ({key, value} -> as_boolean(term))) :: map
+  def filter(map, fun) when is_map(map) and is_function(fun, 1) do
+    iter = :maps.iterator(map)
+    next = :maps.next(iter)
+    :maps.from_list(do_filter(next, fun))
   end
 
-  @doc false
-  @deprecated "Use Enum.reject/2 instead"
-  def reject(map, fun) when is_map(map) do
-    Enum.reject(map, fun) |> :maps.from_list()
+  defp do_filter(:none, _fun), do: []
+
+  defp do_filter({key, value, iter}, fun) do
+    if fun.({key, value}) do
+      [{key, value} | do_filter(:maps.next(iter), fun)]
+    else
+      do_filter(:maps.next(iter), fun)
+    end
+  end
+
+  @doc """
+  Returns map excluding the pairs from `map` for which `fun` returns
+  a truthy value.
+
+  See also `filter/2`.
+
+  ## Examples
+
+      iex> Map.reject(%{one: 1, two: 2, three: 3}, fn {_key, val} -> rem(val, 2) == 1 end)
+      %{two: 2}
+
+  """
+  @doc since: "1.13.0"
+  @spec reject(map, ({key, value} -> as_boolean(term))) :: map
+  def reject(map, fun) when is_map(map) and is_function(fun, 1) do
+    iter = :maps.iterator(map)
+    next = :maps.next(iter)
+    :maps.from_list(do_reject(next, fun))
+  end
+
+  defp do_reject(:none, _fun), do: []
+
+  defp do_reject({key, value, iter}, fun) do
+    if fun.({key, value}) do
+      do_reject(:maps.next(iter), fun)
+    else
+      [{key, value} | do_reject(:maps.next(iter), fun)]
+    end
   end
 
   @doc false