     if item > first, do: :error, else: {:ok, item}
   end
 
+  ## filter
+
+  defp filter_list([head | tail], fun) do
+    if fun.(head) do
+      [head | filter_list(tail, fun)]
+    else
+      filter_list(tail, fun)
+    end
+  end
+
+  defp filter_list([], _fun) do
+    []
+  end
+
   ## find
 
-  defp do_find([h | t], default, fun) do
-    if fun.(h) do
-      h
+  defp find_list([head | tail], default, fun) do
+    if fun.(head) do
+      head
     else
-      do_find(t, default, fun)
-    end
-  end
-
-  defp do_find([], default, _) do
+      find_list(tail, default, fun)
+    end
+  end
+
+  defp find_list([], default, _) do
     default
   end
 
   ## find_index
 
-  defp do_find_index([h | t], counter, fun) do
-    if fun.(h) do
+  defp find_index_list([head | tail], counter, fun) do
+    if fun.(head) do
       counter
     else
-      do_find_index(t, counter + 1, fun)
-    end
-  end
-
-  defp do_find_index([], _, _) do
+      find_index_list(tail, counter + 1, fun)
+    end
+  end
+
+  defp find_index_list([], _, _) do
     nil
   end
 
   ## find_value
 
-  defp do_find_value([h | t], default, fun) do
-    fun.(h) || do_find_value(t, default, fun)
-  end
-
-  defp do_find_value([], default, _) do
+  defp find_value_list([head | tail], default, fun) do
+    fun.(head) || find_value_list(tail, default, fun)
+  end
+
+  defp find_value_list([], default, _) do
     default
+  end
+
+  ## reject
+
+  defp reject_list([head | tail], fun) do
+    if fun.(head) do
+      reject_list(tail, fun)
+    else
+      [head | reject_list(tail, fun)]
+    end
+  end
+
+  defp reject_list([], _fun) do
+    []
   end
 
   ## shuffle

  end

  def split(enumerable, count) when count < 0 do
    do_split_reverse(reverse(enumerable), abs(count), [])
  end

  @doc """

  @spec group_by(t, (element -> any), (element -> any)) :: map
  def group_by(enumerable, key_fun, value_fun \\ fn x -> x end)

  def group_by(enumerable, key_fun, value_fun) when is_function(key_fun) do
    reduce(reverse(enumerable), %{}, fn entry, categories ->
      value = value_fun.(entry)
      Map.update(categories, key_fun.(entry), [value], &[value | &1])
