Current section
Files
Jump to
Current section
Files
lib/etna.ex
defprotocol Etna do
@moduledoc """
Etna is a utility library inspired by RubyGem's ActiveSupport.
It provides a convenient function protocol often used in Rails.
"""
@doc """
#### When list
```elixir
iex(1)> Etna.compact([1, 2, nil, 4, 5])
[1, 2, 4, 5]
```
#### When map
```elixir
iex(1)> Etna.compact(%{a: 10, b: nil})
%{a: 10}
```
"""
def compact(enum)
@doc """
#### when list
```elixir
iex(2)> Etna.include?([1,2,3], 1)
true
iex(3)> Etna.include?([1,2,3], 4)
false
```
#### when map
```elixir
iex(2)> Etna.include?(%{a: 10}, :a)
true
iex(3)> Etna.include?(%{a: 10}, :b)
false
```
"""
def include?(enum, val)
@doc """
#### when list
```elixir
iex(4)> Etna.exclude?([1,2,3], 4)
true
iex(5)> Etna.exclude?([1,2,3], 3)
false
```
#### when map
```elixir
iex(4)> Etna.exclude?(%{a: 10}, :a)
false
iex(5)> Etna.exclude?(%{a: 10}, :b)
true
```
"""
def exclude?(enum, val)
@doc """
#### when list
```elixir
iex(9)> Etna.sum([10, 20, 30])
60
iex(10)> Etna.sum(["a", "b", "c"])
"abc"
iex(11)> Etna.sum([[1,2,3], [4,5,6]])
21
```
#### when map
```elixir
iex(6)> Etna.sum(%{a: 10, b: 20})
30
iex(7)> Etna.sum(%{a: "hello", b: "world"})
"helloworld"
iex(8)> Etna.sum(%{a: [1, 2], b: [3, 4]})
10
```
"""
def sum(enum)
@doc """
#### when list
```elixir
iex(9)> Etna.sum([%{age: 20}, %{age: 30}], fn m -> m.age end)
50
```
#### when map
```elixir
iex(9)> Etna.sum(%{a: 10}, fn -> nil end)
{:error, Etna.Map}
```
"""
def sum(enum, f)
@doc """
#### when list
```elixir
iex(4)> Etna.index_by([%{age: 28, name: "pantani"}, %{age: 30, name: "nibali"}], fn rider -> rider.age end)
%{28 => %{age: 28, name: "pantani"}, 30 => %{age: 30, name: "nibali"}}
```
#### when map
```elixir
iex(10)> Etna.index_by(%{name: "pantani", age: 20, job: :rider}, fn {k, _} -> k end)
%{age: {:age, 20}, job: {:job, :rider}, name: {:name, "pantani"}}
```
"""
def index_by(enum, f)
@doc """
#### when list
```elixir
iex(5)> Etna.many?([1])
true
iex(6)> Etna.many?([])
false
iex(7)> Etna.many?([1, 3])
true
```
#### when map
```elixir
iex(11)> Etna.many?(%{})
false
iex(12)> Etna.many?(%{key: 10})
true
```
"""
def many?(enum)
@doc """
#### when list
```elixir
iex(8)> Etna.without([1, 2, 3, 4, 5], 2)
[1, 3, 4, 5]
iex(9)> Etna.without([1, 2, 3, 4, 5], [1, 4])
[2, 3, 5]
iex(10)> Etna.without(["apple", "orange", "banana"], "banana")
["apple", "orange"]
iex(11)> Etna.without(["apple", "orange", "banana"], ["banana", "orange"])
["apple"]
```
#### when map
```elixir
iex(13)> Etna.without(%{name: "pantani", age: 28, job: :rider}, :name)
%{age: 28, job: :rider}
```
"""
def without(enum, list)
@doc """
#### when list
```elixir
iex(12)> Etna.pluck([%{name: "pantani", age: 28}, %{name: "nibali", age: 30}], :name)
["pantani", "nibali"]
```
#### when map
```elixir
iex(14)> Etna.pluck(%{key: "value"}, :key)
{:error, Etna.Map}
```
"""
def pluck(enum, list)
@doc """
#### when list
```elixir
iex(13)> Etna.to([0, 1, 2, 3, 4, 5], 2)
[0, 1, 2]
```
#### when map
```elixir
iex(15)> Etna.to(%{key: "value"}, 2)
{:error, Etna.Map}
```
"""
def to(list, index)
@doc """
#### when list
```elixir
iex(14)> Etna.from([0, 1, 2, 3, 4, 5, 6, 7, 8], 3)
[4, 5, 6, 7, 8]
```
#### when map
```elixir
iex(16)> Etna.from(%{key: "value"}, 1)
{:error, Etna.Map}
```
"""
def from(list, index)
@doc """
#### when list
```elixir
iex(15)> Etna.except([], :some_key)
{:error, Etna.List}
```
#### when map
```elixir
iex(17)> Etna.except(%{name: "pantani", age: 28, job: :rider}, :name)
%{age: 28, job: :rider}
```
"""
def except(map, key)
@doc """
#### when list
```elixir
iex(16)> Etna.stringify_keys([])
{:error, Etna.List}
```
#### when map
```elixir
iex(18)> Etna.stringify_keys(%{name: "pantani", age: 28})
%{"age" => 28, "name" => "pantani"}
```
"""
def stringify_keys(map)
@doc """
#### when list
```elixir
iex(17)> Etna.symbolize_keys([])
{:error, Etna.List}
```
#### when map
```elixir
iex(19)> Etna.symbolize_keys(%{"name" => "pantani", "age" => 28})
%{age: 28, name: "pantani"}
```
"""
def symbolize_keys(map)
@doc """
#### when list
```elixir
iex(18)> Etna.blank?([])
true
iex(20)> Etna.blank?([1, 2])
false
iex(21)> Etna.blank?([nil])
false
```
#### when map
```elixir
iex(20)> Etna.blank?(%{})
true
iex(21)> Etna.blank?(%{key: 10})
false
```
"""
def blank?(val)
@doc """
#### when list
```elixir
iex(22)> Etna.present?([])
false
iex(23)> Etna.present?([1, 2])
true
```
#### when map
```elixir
iex(22)> Etna.present?(%{})
false
iex(23)> Etna.present?(%{key: 10})
true
```
"""
def present?(val)
@doc """
#### when list
```elixir
iex(24)> Etna.wrap([1, 2])
[1, 2]
iex(25)> Etna.wrap([])
[]
```
#### when map
```elixir
iex(24)> Etna.wrap(%{})
[%{}]
iex(25)> Etna.wrap(%{name: "pantani", age: 28})
[%{age: 28, name: "pantani"}]
```
"""
def wrap(val)
end