Elixir library: add support to Enumerable to Enum.find_index/find_value

Code has been taken from here:
https://raw.githubusercontent.com/elixir-lang/elixir/v1.10.4/lib/elixir/lib/enum.ex

Signed-off-by: Davide Bettio <davide@uninstall.it>

Author: bettio

CHANGELOG.md

@@ -23,6 +23,7 @@ also non string parameters (e.g. `Enum.join([1, 2], ",")`
 
 - ESP32: Elixir library is not shipped anymore with `esp32boot.avm`. Use `elixir_esp32boot.avm`
 instead
+- `Enum.find_index` and `Enum.find_value` support Enumerable and not just lists
 
 ### Fixed
 

libs/exavmlib/lib/Enum.ex

@@ -398,14 +398,67 @@ defmodule Enum do
     |> elem(1)
   end
 
+  @doc """
+  Similar to `find/3`, but returns the index (zero-based)
+  of the element instead of the element itself.
+
+  ## Examples
+
+      iex> Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end)
+      nil
+
+      iex> Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end)
+      1
+
+  """
+  @spec find_index(t, (element -> any)) :: non_neg_integer | nil
   def find_index(enumerable, fun) when is_list(enumerable) do
     find_index_list(enumerable, 0, fun)
   end
 
+  def find_index(enumerable, fun) do
+    result =
+      Enumerable.reduce(enumerable, {:cont, {:not_found, 0}}, fn entry, {_, index} ->
+        if fun.(entry), do: {:halt, {:found, index}}, else: {:cont, {:not_found, index + 1}}
+      end)
+
+    case elem(result, 1) do
+      {:found, index} -> index
+      {:not_found, _} -> nil
+    end
+  end
+
+  @doc """
+  Similar to `find/3`, but returns the value of the function
+  invocation instead of the element itself.
+
+  ## Examples
+
+      iex> Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end)
+      nil
+
+      iex> Enum.find_value([2, 3, 4], fn x -> rem(x, 2) == 1 end)
+      true
+
+      iex> Enum.find_value([1, 2, 3], "no bools!", &is_boolean/1)
+      "no bools!"
+
+  """
+  @spec find_value(t, any, (element -> any)) :: any | nil
+  def find_value(enumerable, default \\ nil, fun)
+
   def find_value(enumerable, default, fun) when is_list(enumerable) do
     find_value_list(enumerable, default, fun)
   end
 
+  def find_value(enumerable, default, fun) do
+    Enumerable.reduce(enumerable, {:cont, default}, fn entry, default ->
+      fun_entry = fun.(entry)
+      if fun_entry, do: {:halt, fun_entry}, else: {:cont, default}
+    end)
+    |> elem(1)
+  end
+
   @doc """
   Maps the given `fun` over `enumerable` and flattens the result.
 

tests/libs/exavmlib/Tests.ex

@@ -39,6 +39,8 @@ defmodule Tests do
     [2, 3] = Enum.slice([1, 2, 3], 1, 2)
     :test = Enum.at([0, 1, :test, 3], 2)
     :atom = Enum.find([1, 2, :atom, 3, 4], -1, fn item -> not is_integer(item) end)
+    1 = Enum.find_index([:a, :b, :c], fn item -> item == :b end)
+    true = Enum.find_value([-2, -3, -1, 0, 1], fn item -> item >= 0 end)
     true = Enum.all?([1, 2, 3], fn n -> n >= 0 end)
     true = Enum.any?([1, -2, 3], fn n -> n < 0 end)
     [2] = Enum.filter([1, 2, 3], fn n -> rem(n, 2) == 0 end)
@@ -64,6 +66,7 @@ defmodule Tests do
     true = at_0 != at_1
     {:c, :atom} = Enum.find(%{a: 1, b: 2, c: :atom, d: 3}, fn {_k, v} -> not is_integer(v) end)
     {:d, 3} = Enum.find(%{a: 1, b: 2, c: :atom, d: 3}, fn {k, _v} -> k == :d end)
+    true = Enum.find_value(%{"a" => 1, b: 2}, fn {k, _v} -> is_atom(k) end)
     true = Enum.all?(%{a: 1, b: 2}, fn {_k, v} -> v >= 0 end)
     true = Enum.any?(%{a: 1, b: -2}, fn {_k, v} -> v < 0 end)
     [b: 2] = Enum.filter(%{a: 1, b: 2, c: 3}, fn {_k, v} -> rem(v, 2) == 0 end)
@@ -82,6 +85,7 @@ defmodule Tests do
     true = ms_at_0 == 1 or ms_at_0 == 2
     true = ms_at_1 == 1 or ms_at_1 == 2
     :atom = Enum.find(MapSet.new([1, 2, :atom, 3, 4]), fn item -> not is_integer(item) end)
+    nil = Enum.find_value([-2, -3, -1, 0, 1], fn item -> item > 100 end)
     true = Enum.all?(MapSet.new([1, 2, 3]), fn n -> n >= 0 end)
     true = Enum.any?(MapSet.new([1, -2, 3]), fn n -> n < 0 end)
     [2] = Enum.filter(MapSet.new([1, 2, 3]), fn n -> rem(n, 2) == 0 end)
@@ -97,6 +101,7 @@ defmodule Tests do
     [6, 7, 8, 9, 10] = Enum.slice(1..10, 5, 100)
     7 = Enum.at(1..10, 6)
     8 = Enum.find(-10..10, fn item -> item >= 8 end)
+    true = Enum.find_value(-10..10, fn item -> item >= 0 end)
     true = Enum.all?(0..10, fn n -> n >= 0 end)
     true = Enum.any?(-1..10, fn n -> n < 0 end)
     [0, 1, 2] = Enum.filter(-10..2, fn n -> n >= 0 end)