iteraptor v1.0.1 Iteraptor View Source
Iteraptor
makes complicated nested structures (currently map
s, list
s
and Keyword
s) iteration easier.
Usage
Iterating, Mapping, Reducing
Iteraptor.each/3
to iterate a deeply nested map/list/keyword;Iteraptor.map/3
to map a deeply nested map/list/keyword;Iteraptor.reduce/4
to reduce a deeply nested map/list/keyword;Iteraptor.map_reduce/4
to map and reduce a deeply nested map/list/keyword;
Flattening
Iteraptor.to_flatmap/2
to flatten a deeply nested map/list/keyword into flatten map with concatenated keys;Iteraptor.from_flatmap/3
to “unveil”/“unflatten” the previously flattened map into nested structure;
Link to this section Summary
Functions
Iterates the given nested structure, calling the callback provided on each value. The key returned is an array of all the parent keys (and/or indices in a case of an array.)
Build a nested structure out of a flatmap given, decomposing the names of keys and handling lists carefully
Maps the given nested structure, calling the callback provided on each value. The key returned is a concatenated names of all the parent keys (and/or indices in a case of an array.)
Iteration with mapping and reducing. The function of arity 2
, called back on each
iteration with {k, v}
pair and an accumulator is accepted
Iteration with reducing. The function of arity 2
, called back on each
iteration with {k, v}
pair and an accumulator is accepted
Build a flatmap out of nested structure, concatenating the names of keys
Link to this section Functions
Iterates the given nested structure, calling the callback provided on each value. The key returned is an array of all the parent keys (and/or indices in a case of an array.)
The return value is self
.
Parameters
input
: nested map/list/keyword to be walked through.fun
: callback to be called on each{key, value}
pair, wherekey
is an array or deeply nested keys; e.g. on%{a: {b: 42}}
will be called once, with tuple{[:a, :b], 42}
;opts
: the options to be passed to the iterationyield
:[:all | :maps | :keywords |
what to yield; default:nil
for yielding values only.
Examples
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.each(&IO.inspect/1)
{[:a, :b, :c], 42}
%{a: %{b: %{c: 42}}}
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.each(&IO.inspect/1, yield: :all)
{[:a], %{b: %{c: 42}}}
{[:a, :b], %{c: 42}}
{[:a, :b, :c], 42}
%{a: %{b: %{c: 42}}}
Build a nested structure out of a flatmap given, decomposing the names of keys and handling lists carefully.
%{"a.b.c": 42, "a.b.d.0": nil, "a.b.d.1": 42, "a.e.0": :f, "a.e.1": 42}
|> Iteraptor.from_flatmap
#⇒ %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}}
Parameters
input
: flat map to be “expanded” to nested maps/lists,transformer
: the transformer function to be called on all the elements,opts
: additional options to be passed through.
Examples
iex> %{"a.b.c": 42} |> Iteraptor.from_flatmap
%{a: %{b: %{c: 42}}}
iex> %{"a.b.c": 42, "a.b.d": 42} |> Iteraptor.from_flatmap
%{a: %{b: %{c: 42, d: 42}}}
iex> %{"a.b.c": 42, "a.b.d": 42, "a.e": 42} |> Iteraptor.from_flatmap
%{a: %{b: %{c: 42, d: 42}, e: 42}}
iex> %{"0": 42, "1": 42} |> Iteraptor.from_flatmap
[42, 42]
iex> %{"1": :a1, "0": :a0, "2": :a2, "3": :a3, "4": :a4, "5": :a5,
...> "6": :a6, "7": :a7, "8": :a8, "9": :a9, "10": :a10, "11": :a11}
...> |> Iteraptor.from_flatmap
[:a0, :a1, :a2, :a3, :a4, :a5, :a6, :a7, :a8, :a9, :a10, :a11]
iex> %{"0.a": 42, "0.b": 42} |> Iteraptor.from_flatmap
[%{a: 42, b: 42}]
iex> %{"a.0.0" => :b, "a.1" => 42, d: 42} |> Iteraptor.from_flatmap
%{a: [[:b], 42], d: 42}
iex> %{"a.b.c": 42, "a.b.d.0": nil, "a.b.d.1": 42, "a.e.0": :f, "a.e.1": 42}
...> |> Iteraptor.from_flatmap
%{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}}
iex> %{"0.a": 42, "0.b": 42} |> Iteraptor.from_flatmap(&IO.inspect/1)
{[0, :a], 42}
{[0, :b], 42}
[%{a: 42, b: 42}]
Maps the given nested structure, calling the callback provided on each value. The key returned is a concatenated names of all the parent keys (and/or indices in a case of an array.)
The return value is the result of subsequent calls to the transformer given.
Parameters
input
: nested map/list/keyword to be mapped.fun
: callback to be called on each{key, value}
pair, wherekey
is an array or deeply nested keys; e.g. on%{a: {b: 42}}
will be called once, with tuple{[:a, :b], 42}
;opts
: the options to be passed to the iterationyield
:[:all | :maps | :keywords |
what to yield; default:nil
for yielding values only.
Examples
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.map(fn {_, v} -> v * 2 end)
%{a: %{b: %{c: 84}}}
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.map(fn {k, _} -> Enum.join(k) end)
%{a: %{b: %{c: "abc"}}}
iex> %{a: %{b: %{c: 42}}}
...> |> Iteraptor.map(fn
...> {[_], _} = self -> self
...> {[_, _], _} -> "YAY"
...> end, yield: :all)
%{a: %{b: "YAY"}}
Iteration with mapping and reducing. The function of arity 2
, called back on each
iteration with {k, v}
pair and an accumulator is accepted.
The return value is the tuple, consisting of mapped input and the accumulator from the last call to the passed map-reducer.
Parameters
input
: nested map/list/keyword to be mapped.fun
: callback to be called on each{key, value}, acc
pair, wherekey
is an array or deeply nested keys,value
is the value andacc
is the accumulator;opts
: the options to be passed to the iterationyield
:[:all | :maps | :keywords |
what to yield; default:nil
for yielding values only.
Examples
iex> %{a: %{b: %{c: 42}}}
...> |> Iteraptor.map_reduce([], fn
...> {k, %{} = v}, acc -> {{k, v}, [Enum.join(k, ".") | acc]}
...> {k, v}, acc -> {{k, v * 2}, [Enum.join(k, ".") <> "=" | acc]}
...> end, yield: :all)
{%{a: %{b: %{c: 84}}}, ["a.b.c=", "a.b", "a"]}
Iteration with reducing. The function of arity 2
, called back on each
iteration with {k, v}
pair and an accumulator is accepted.
The return value is the result of the last call to the passed reducer function.
Parameters
input
: nested map/list/keyword to be mapped.fun
: callback to be called on each{key, value}, acc
pair, wherekey
is an array or deeply nested keys,value
is the value andacc
is the accumulator;opts
: the options to be passed to the iterationyield
:[:all | :maps | :keywords |
what to yield; default:nil
for yielding values only.
Examples
iex> %{a: %{b: %{c: 42}}}
...> |> Iteraptor.reduce([], fn {k, _}, acc ->
...> [Enum.join(k, "_") | acc]
...> end, yield: :all)
...> |> :lists.reverse()
["a", "a_b", "a_b_c"]
Build a flatmap out of nested structure, concatenating the names of keys.
%{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}} |> Iteraptor.to_flatmap
%{"a.b.c": 42, "a.b.d.0": nil, "a.b.d.1": 42, "a.e.0": :f, "a.e.1": 42}
Lists are handled gracefully, index is used as a key in resulting map.
Parameters
input
: nested map/list/keyword/struct to be flattened,opts
: the additional options to be passed through: —delimiter
(default:"."
,) might be passed explicitly or configured with:iteraptor, :delimiter
application setting.
Examples
iex> [:a, 42] |> Iteraptor.to_flatmap
%{0 => :a, 1 => 42}
iex> %{a: 42} |> Iteraptor.to_flatmap
%{a: 42}
iex> %{a: 42, b: 42} |> Iteraptor.to_flatmap
%{a: 42, b: 42}
iex> %{a: %{b: 42}, d: 42} |> Iteraptor.to_flatmap
%{"a.b" => 42, d: 42}
iex> %{a: [:b, 42], d: 42} |> Iteraptor.to_flatmap
%{"a.0" => :b, "a.1" => 42, d: 42}
iex> %{a: %{b: [:c, 42]}, d: 42} |> Iteraptor.to_flatmap
%{"a.b.0" => :c, "a.b.1" => 42, d: 42}
iex> %{a: %{b: 42}} |> Iteraptor.to_flatmap
%{"a.b" => 42}
iex> %{a: %{b: %{c: 42}}} |> Iteraptor.to_flatmap
%{"a.b.c" => 42}
iex> %{a: %{b: %{c: 42}}, d: 42} |> Iteraptor.to_flatmap
%{"a.b.c" => 42, d: 42}
iex> [a: [b: [c: 42]], d: 42] |> Iteraptor.to_flatmap
%{"a.b.c" => 42, d: 42}
iex> [a: [[:b], 42], d: 42] |> Iteraptor.to_flatmap
%{"a.0.0" => :b, "a.1" => 42, d: 42}
iex> %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}} |> Iteraptor.to_flatmap
%{"a.b.c" => 42, "a.b.d.0" => nil, "a.b.d.1" => 42, "a.e.0" => :f, "a.e.1" => 42}
iex> %{a: %{b: %{c: 42, d: [nil, 42]}, e: [:f, 42]}}
...> |> Iteraptor.to_flatmap(delimiter: "_")
%{"a_b_c" => 42, "a_b_d_0" => nil, "a_b_d_1" => 42, "a_e_0" => :f, "a_e_1" => 42}