defmodule RMap.Ruby do
@moduledoc """
Summarized all of Ruby's Hash functions.
Functions corresponding to the following patterns are not implemented
- When a function with the same name already exists in Elixir.
- When a method name includes `!`.
- <, <=, ==, >, >=, [], []=, default_*
"""
@spec __using__(any) :: list
defmacro __using__(_opts) do
RUtils.define_all_functions!(__MODULE__)
end
import RMap.Support
# https://ruby-doc.org/core-3.1.0/Hash.html
# [:any?, :assoc, :clear, :compact, :compact!, :compare_by_identity, :compare_by_identity?, :deconstruct_keys, :delete, :delete_if, :dig, :each, :each_key, :each_pair, :each_value, :empty?, :eql?, :except, :fetch, :fetch_values, :filter, :filter!, :flatten, :has_key?, :has_value?, :hash, :include?, :initialize_copy, :inspect, :invert, :keep_if, :key, :key?, :keys, :length, :member?, :merge, :merge!, :rassoc, :rehash, :reject, :reject!, :replace, :select, :select!, :shift, :size, :slice, :store, :to_a, :to_h, :to_hash, :to_proc, :to_s, :transform_keys, :transform_keys!, :transform_values, :transform_values!, :update, :value?, :values, :values_at]
# |> RUtils.required_functions([Map, REnum])
# ✔ assoc
# ✔ clear
# × compare_by_identity
# × compare_by_identity?
# × deconstruct_keys
# ✔ delete_if
# ✔ dig
# ✔ each_key
# ✔ each_pair
# ✔ each_value
# ✔ eql?
# ✔ except
# ✔ fetch_values
# ✔ flatten
# ✔ has_value?
# hash TODO: Low priority
# × initialize_copy
# ✔ inspect
# ✔ invert
# ✔ keep_if
# ✔ key
# ✔ key?
# ✔ length
# ✔ rassoc
# × rehash
# ✔ shift
# ✔ store
# ✔ to_hash
# × to_proc
# ✔ to_s
# ✔ transform_keys
# ✔ transform_values
# ✔ value?
# ✔ values_at
@doc """
Returns a list whose entries are those for which the function returns a truthy value.
## Examples
iex> RMap.filter(%{a: 1, b: 2, c: 3}, fn {_, v} -> v > 1 end)
%{b: 2, c: 3}
"""
@spec filter(map(), function()) :: map()
def filter(map, func) do
Enum.filter(map, func)
|> Map.new()
end
@doc """
Returns a list whose entries are all those from self for which the function returns false or nil.
## Examples
iex> RMap.reject(%{a: 1, b: 2, c: 3}, fn {_, v} -> v > 1 end)
%{a: 1}
"""
@spec reject(map(), function()) :: map()
def reject(map, func) do
Enum.reject(map, func)
|> Map.new()
end
@doc """
Returns %{}.
## Examples
iex> RMap.clear(%{a: 1, b: 2, c: 3})
%{}
"""
@spec clear(map()) :: %{}
def clear(_) do
%{}
end
@doc """
Calls the function with each value; returns :ok.
## Examples
iex> RMap.each_value(%{a: 1, b: 2, c: 3}, &IO.inspect(&1))
# 1
# 2
# 3
:ok
"""
@spec each_value(map(), function()) :: :ok
def each_value(map, func) do
Enum.each(map, fn {_, value} ->
func.(value)
end)
end
@doc """
Calls the function with each key; returns :ok.
## Examples
iex> RMap.each_key(%{a: 1, b: 2, c: 3}, &IO.inspect(&1))
# :a
# :b
# :c
:ok
"""
@spec each_key(map(), function()) :: :ok
def each_key(map, func) do
Enum.each(map, fn {key, _} ->
func.(key)
end)
end
@doc """
Returns true if value is a value in list, otherwise false.
## Examples
iex> RMap.value?(%{a: 1, b: 2, c: 3}, 3)
true
iex> RMap.value?(%{a: 1, b: 2, c: 3}, 4)
false
"""
@spec value?(map(), any) :: boolean()
def value?(map, value) do
Enum.any?(map, fn {_, v} ->
v == value
end)
end
@doc """
Returns a list containing values for the given keys.
## Examples
iex> RMap.values_at(%{a: 1, b: 2, c: 3}, [:a, :b, :d])
[1, 2, nil]
"""
@spec values_at(map(), list()) :: list()
def values_at(map, keys) do
Enum.map(keys, &Map.get(map, &1))
end
@doc """
Returns given map.
## Examples
iex> RMap.to_hash(%{a: 1, b: 2, c: 3})
%{a: 1, b: 2, c: 3}
"""
@spec to_hash(map()) :: map()
def to_hash(map) do
map
end
@doc """
Returns the object in nested map that is specified by a given key and additional arguments.
## Examples
iex> RMap.dig(%{a: %{b: %{c: 1}}}, [:a, :b, :c])
1
iex> RMap.dig(%{a: %{b: %{c: 1}}}, [:a, :c, :b])
nil
"""
def dig(nil, _), do: nil
def dig(result, []), do: result
@spec dig(map(), list()) :: any()
def dig(map, keys) do
[key | tail_keys] = keys
result = Map.get(map, key)
dig(result, tail_keys)
end
@doc """
Returns a 2-element tuple containing a given key and its value.
## Examples
iex> RMap.assoc(%{a: 1, b: 2, c: 3}, :a)
{:a, 1}
iex> RMap.assoc(%{a: 1, b: 2, c: 3}, :d)
nil
iex> RMap.assoc(%{a: %{b: %{c: 1}}}, :a)
{:a, %{b: %{c: 1}}}
"""
@spec assoc(map(), any()) :: any()
def assoc(map, key) do
if(value = Map.get(map, key)) do
{key, value}
else
nil
end
end
@doc """
Returns a 2-element tuple consisting of the key and value of the first-found entry having a given value.
## Examples
iex> RMap.rassoc(%{a: 1, b: 2, c: 3}, 1)
{:a, 1}
iex> RMap.rassoc(%{a: 1, b: 2, c: 3}, 4)
nil
iex> RMap.rassoc(%{a: %{b: %{c: 1}}}, %{b: %{c: 1}})
{:a, %{b: %{c: 1}}}
"""
@spec rassoc(map(), any()) :: any()
def rassoc(map, value) do
Enum.find_value(map, fn {k, v} ->
if v == value, do: {k, v}
end)
end
@doc """
Returns a map with modified keys.
## Examples
iex> RMap.transform_keys(%{a: 1, b: 2, c: 3}, &to_string(&1))
%{"a" => 1, "b" => 2, "c" => 3}
iex> RMap.transform_keys(%{a: %{b: %{c: 1}}}, &to_string(&1))
%{"a" => %{b: %{c: 1}}}
"""
@spec transform_keys(map(), function()) :: map()
def transform_keys(map, func) do
Enum.map(map, fn {key, value} ->
{func.(key), value}
end)
|> Map.new()
end
@doc """
Returns a map with modified values.
## Examples
iex> RMap.transform_values(%{a: 1, b: 2, c: 3}, &inspect(&1))
%{a: "1", b: "2", c: "3"}
iex> RMap.transform_values(%{a: %{b: %{c: 1}}}, &inspect(&1))
%{a: "%{b: %{c: 1}}"}
"""
@spec transform_values(map(), function()) :: map()
def transform_values(map, func) do
Enum.map(map, fn {key, value} ->
{key, func.(value)}
end)
|> Map.new()
end
@doc """
Returns a map excluding entries for the given keys.
## Examples
iex> RMap.except(%{a: 1, b: 2, c: 3}, [:a, :b])
%{c: 3}
"""
@spec except(map(), list()) :: map()
def except(map, keys) do
delete_if(map, fn {key, _} ->
key in keys
end)
end
@doc """
Returns a list containing the values associated with the given keys.
## Examples
iex> RMap.fetch_values(%{ "cat" => "feline", "dog" => "canine", "cow" => "bovine" }, ["cow", "cat"])
["bovine", "feline"]
iex> RMap.fetch_values(%{ "cat" => "feline", "dog" => "canine", "cow" => "bovine" }, ["cow", "bird"])
** (MapKeyError) key not found: bird
"""
@spec fetch_values(map(), list()) :: list()
def fetch_values(map, keys) do
Enum.map(keys, fn key ->
if(value = map |> Map.get(key)) do
value
else
raise MapKeyError, "key not found: #{key}"
end
end)
end
@doc """
When a function is given, calls the function with each missing key, treating the block's return value as the value for that key.
## Examples
iex> RMap.fetch_values(%{ "cat" => "feline", "dog" => "canine", "cow" => "bovine" }, ["cow", "bird"], &(String.upcase(&1)))
["bovine", "BIRD"]
"""
@spec fetch_values(map(), list(), function()) :: list()
def fetch_values(map, keys, func) do
Enum.map(keys, fn key ->
if(value = map |> Map.get(key)) do
value
else
func.(key)
end
end)
end
@doc """
Returns a flatten list.
## Examples
iex> RMap.flatten(%{1=> "one", 2 => [2,"two"], 3 => "three"})
[1, "one", 2, 2, "two", 3, "three"]
iex> RMap.flatten(%{1 => "one", 2 => %{a: 1, b: %{c: 3}}})
[1, "one", 2, :a, 1, :b, :c, 3]
"""
@spec flatten(map()) :: list()
def flatten(map) do
deep_to_list(map) |> List.flatten()
end
@doc """
Returns a map object with the each key-value pair inverted.
## Examples
iex> RMap.invert(%{"a" => 0, "b" => 100, "c" => 200, "d" => 300, "e" => 300})
%{0 => "a", 100 => "b", 200 => "c", 300 => "e"}
iex> RMap.invert(%{a: 1, b: 1, c: %{d: 2}})
%{1 => :b, %{d: 2} => :c}
"""
@spec invert(map()) :: map()
def invert(map) do
map
|> Enum.map(fn {k, v} ->
{v, k}
end)
|> Map.new()
end
@doc """
Removes the first map entry; returns a 2-element tuple.
First element is {key, value}.
Second element is a map without first pair.
## Examples
iex> RMap.shift(%{a: 1, b: 2, c: 3})
{{:a, 1}, %{b: 2, c: 3}}
iex> RMap.shift(%{})
{nil, %{}}
"""
@spec shift(map()) :: {tuple() | nil, map()}
def shift(map) do
{result, list} = map |> Enum.split(1)
{List.last(result), Map.new(list)}
end
defdelegate delete_if(map, func), to: __MODULE__, as: :reject
defdelegate keep_if(map, func), to: __MODULE__, as: :filter
defdelegate select(map, func), to: __MODULE__, as: :filter
defdelegate length(map), to: Enum, as: :count
defdelegate size(map), to: Enum, as: :count
defdelegate to_s(map), to: Kernel, as: :inspect
defdelegate inspect(map), to: Kernel, as: :inspect
defdelegate each_pair(map, func), to: Enum, as: :each
defdelegate key(map, key, default \\ nil), to: Map, as: :get
defdelegate key?(map, key), to: Map, as: :has_key?
defdelegate has_value?(map, value), to: __MODULE__, as: :value?
defdelegate store(map, key, value), to: Map, as: :put
defdelegate eql?(map1, map2), to: Map, as: :equal?
end
defmodule MapKeyError do
defexception [:message]
end
