View Source Modifiers tutorial
Every pathex path
created with Pathex.path/2
can have modifier specified as a second argument.
Modifier defines behaviour of the path in a way of structures it can match inside.
For example, path created with :map
modifier can only match maps inside them.
Modifiers can be specified only in form of an atom, variables are not accepted.
usage
Usage
Currently only three modifiers are available:
:json
which matches lists and maps:naive
which matches lists, tuples, keywords and maps:map
which matches only maps
Default modifier for every path is
:naive
Modifiers are specified as second argument in path/2
like
path :x / :y, :naive
path 0 / :x, :json
naive-modifier
Naive modifier
This modifier matches lists, tuples, keyword and maps It generates matches for every structure like
For example path(:x, :naive)
generates something like
case input do
%{x: value} ->
...
[{a, _} | _] = k when is_atom(a) ->
case Keyword.fetch(k, :x) do
...
end
end
Note: Variables are treated as their values
json-modifier
Json modifier
This modifier specifies paths which macth lists (for integer keys only) and maps
Note: This modifier treats variables as map keys, this means that
iex> x = 1 iex> p = path x, :json iex> :error = Pathex.view([1, 2, 3], p) iex> {:ok, :x} = Pathex.view(%{1 => :x}, p)
But passed integers are exanded into list matching this makes it very efficient to view data from the structure
For example path 1 / :x, :json
generates closure with
case input do
[_, %{x: value} | _] ->
{:ok, value}
%{1 => %{x: value}} ->
{:ok, value}
_ ->
:error
end
Which extracts maximum efficiency from BEAM's pattern-matching
map-modifier
Map modifier
This modifier matches only maps and therefore is the fastest modifier available
For example path 1 / :x / "y", :map
will generate closure with
case input do
%{1 => %{x: %{"y" => value}}} ->
{:ok, value}
_ ->
:error
end
annotations
Annotations
Usually a key passed to path
can match to one or more types. For example, key :x
can be a key in Map
like %{x: 1}
and a key in Keyword
like [x: 1]
. To make key match only certain type it can be annotated to the exact type using this syntax path(:x :: :map)
. Available annotations are :map
, :keyword
, :list
and :tuple
.
when-how-why
When? How? & Why?
You should use modifiers when you need to specify type of inner structures to match
or reduce amount of generated code by Pathex
or improve performance of the path