@spec allowed_operators(Flop.FieldInfo.t() | Flop.Schema.ecto_type() | nil) :: [op()]

Returns the allowed operators for the given Ecto type.

If the given value is not a native Ecto type, a list with all operators is returned.

iex> allowed_operators(:integer)
[:==, :!=, :empty, :not_empty, :<=, :<, :>=, :>, :in, :not_in]

@spec allowed_operators(atom(), atom()) :: [op()]

Returns the allowed operators for the given schema module and field.

For regular Ecto schema fields, the type is derived via schema reflection.

If the given schema module derives Flop.Schema, the type of join and custom fields is determined via the ecto_type option. Compound files are always handled as string fields, minus unsupported operators.

If the type cannot be determined or if the type is not a native Ecto type, a list with all operators is returned.

iex> allowed_operators(Pet, :age)
[:==, :!=, :empty, :not_empty, :<=, :<, :>=, :>, :in, :not_in]

@spec delete([t()] | [map()] | map(), atom()) :: [t()] | [map()]

Deletes the filters for the given field from a list of filters.

Examples

Flop.Filter struct

iex> delete(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8}
...>   ],
...>   :name
...> )
[%Flop.Filter{field: :age, op: :>, value: 8}]

iex> delete(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
[%Flop.Filter{field: :age, op: :>, value: 8}]

iex> delete([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
[%Flop.Filter{field: :name, op: :==, value: "Joe"}]

Map with atom keys

iex> delete(
...>   [
...>     %{field: :name, op: :==, value: "Joe"},
...>     %{field: :age, op: :>, value: 8}
...>   ],
...>   :name
...> )
[%{field: :age, op: :>, value: 8}]

Map with string keys

iex> delete(
...>   [
...>     %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     %{"field" => "age", "op" => ">", "value" => "8"}
...>   ],
...>   :name
...> )
[%{"field" => "age", "op" => ">", "value" => "8"}]

Indexed map

Filters passed as an indexed map will be converted to a list, even if no matching filter exists.

iex> delete(
...>   %{
...>     0 => %{field: "name", op: "==", value: "Joe"},
...>     1 => %{field: "age", op: ">", value: "8"}
...>   },
...>   :name
...> )
[%{field: "age", op: ">", value: "8"}]

iex> delete(
...>   %{
...>     "0" => %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     "1" => %{"field" => "age", "op" => ">", "value" => "8"}
...>   },
...>   :name
...> )
[%{"field" => "age", "op" => ">", "value" => "8"}]

@spec delete_first([t()] | [map()] | map(), atom()) :: [t()] | [map()]

Deletes the first filter in list of filters for the given field.

Examples

Flop.Filter struct

iex> delete_first(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
[
  %Flop.Filter{field: :age, op: :>, value: 8},
  %Flop.Filter{field: :name, op: :==, value: "Jim"}
]

iex> delete_first([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
[%Flop.Filter{field: :name, op: :==, value: "Joe"}]

Map with atom keys

iex> delete_first(
...>   [
...>     %{field: :name, op: :==, value: "Joe"},
...>     %{field: :age, op: :>, value: 8},
...>     %{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
[
  %{field: :age, op: :>, value: 8},
  %{field: :name, op: :==, value: "Jim"}
]

Map with string keys

iex> delete_first(
...>   [
...>     %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     %{"field" => "age", "op" => ">", "value" => 8},
...>     %{"field" => "name", "op" => "==", "value" => "Jim"}
...>   ],
...>   :name
...> )
[
  %{"field" => "age", "op" => ">", "value" => 8},
  %{"field" => "name", "op" => "==", "value" => "Jim"}
]

iex> delete_first(
...>   [
...>     %{"field" => :name, "op" => :==, "value" => "Joe"},
...>     %{"field" => :age, "op" => :>, "value" => 8},
...>     %{"field" => :name, "op" => :==, "value" => "Jim"}
...>   ],
...>   :name
...> )
[
  %{"field" => :age, "op" => :>, "value" => 8},
  %{"field" => :name, "op" => :==, "value" => "Jim"}
]

Indexed map

Filters passed as an indexed map will be converted to a list, even if no matching filter exists.

iex> delete_first(
...>   %{
...>     0 => %{field: "name", op: "==", value: "Joe"},
...>     1 => %{field: "age", op: ">", value: 8},
...>     2 => %{field: "name", op: "==", value: "Jim"}
...>   },
...>   :name
...> )
[
  %{field: "age", op: ">", value: 8},
  %{field: "name", op: "==", value: "Jim"}
]

iex> delete_first(
...>   %{
...>     "0" => %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     "1" => %{"field" => "age", "op" => ">", "value" => 8},
...>     "2" => %{"field" => "name", "op" => "==", "value" => "Jim"}
...>   },
...>   :name
...> )
[
  %{"field" => "age", "op" => ">", "value" => 8},
  %{"field" => "name", "op" => "==", "value" => "Jim"}
]

@spec drop([t()] | [map()] | map(), [atom()]) :: [t()] | [map()]

Removes the filters for the given fields from a list of filters.

Examples

Flop.Filter struct

iex> drop(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :color, op: :==, value: "blue"}
...>   ],
...>   [:name, :color]
...> )
[%Flop.Filter{field: :age, op: :>, value: 8}]

iex> drop(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :color, op: :==, value: "blue"},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   [:name, :species]
...> )
[
  %Flop.Filter{field: :age, op: :>, value: 8},
  %Flop.Filter{field: :color, op: :==, value: "blue"}
]

Map with atom keys

iex> drop(
...>   [
...>     %{field: :name, op: :==, value: "Joe"},
...>     %{field: :age, op: :>, value: 8},
...>     %{field: :color, op: :==, value: "blue"}
...>   ],
...>   [:name, :color]
...> )
[%{field: :age, op: :>, value: 8}]

Map with string keys

iex> drop(
...>   [
...>     %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     %{"field" => "age", "op" => ">", "value" => "8"},
...>     %{"field" => "color", "op" => "==", "value" => "blue"}
...>   ],
...>   [:name, :color]
...> )
[%{"field" => "age", "op" => ">", "value" => "8"}]

iex> drop(
...>   [
...>     %{"field" => :name, "op" => :==, "value" => "Joe"},
...>     %{"field" => :age, "op" => :>, "value" => "8"},
...>     %{"field" => :color, "op" => :==, "value" => "blue"}
...>   ],
...>   [:name, :color]
...> )
[%{"field" => :age, "op" => :>, "value" => "8"}]

Indexed map

Filters passed as an indexed map will be converted to a list, even if no matching filter exists.

iex> drop(
...>   %{
...>     0 => %{field: "name", op: "==", value: "Joe"},
...>     1 => %{field: "age", op: ">", value: "8"},
...>     2 => %{field: "color", op: "==", value: "blue"}
...>   },
...>   [:name, :color]
...> )
[%{field: "age", op: ">", value: "8"}]

iex> drop(
...>   %{
...>     "0" => %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     "1" => %{"field" => "age", "op" => ">", "value" => "8"},
...>     "2" => %{"field" => "color", "op" => "==", "value" => "blue"}
...>   },
...>   [:name, :color]
...> )
[%{"field" => "age", "op" => ">", "value" => "8"}]

@spec fetch([t()] | [map()] | map(), atom()) :: {:ok, t() | map()} | :error

Fetches the first filter for the given field and returns it in a tuple.

Examples

Flop.Filter struct

iex> fetch([], :name)
:error

iex> fetch([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
{:ok, %Flop.Filter{field: :name, op: :==, value: "Joe"}}

iex> fetch([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
:error

iex> fetch(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
{:ok, %Flop.Filter{field: :name, op: :==, value: "Joe"}}

Map with atom keys

iex> fetch([%{field: :name, op: :==, value: "Joe"}], :name)
{:ok, %{field: :name, op: :==, value: "Joe"}}

Map with string keys

iex> fetch([%{"field" => "name", "op" => "==", "value" => "Joe"}], :name)
{:ok, %{"field" => "name", "op" => "==", "value" => "Joe"}}

Indexed map

iex> fetch(
...>   %{0 => %{field: "name", op: "==", value: "Joe"}},
...>   :name
...> )
{:ok, %{field: "name", op: "==", value: "Joe"}}

iex> fetch(
...>   %{"0" => %{"field" => "name", "op" => "==", "value" => "Joe"}},
...>   :name
...> )
{:ok, %{"field" => "name", "op" => "==", "value" => "Joe"}}

@spec fetch_value([t()] | [map()] | map(), atom()) :: {:ok, any()} | :error

Fetches the first filter value for the given field and returns it in a tuple.

Examples

Flop.Filter struct

iex> fetch_value([], :name)
:error

iex> fetch_value([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
{:ok, "Joe"}

iex> fetch_value([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
:error

iex> fetch_value(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
{:ok, "Joe"}

Map with atom keys

iex> fetch_value([%{field: :name, op: :==, value: "Joe"}], :name)
{:ok, "Joe"}

Map with string keys

iex> fetch_value(
...>   [%{"field" => "name", "op" => "==", "value" => "Joe"}],
...>   :name
...> )
{:ok, "Joe"}

Indexed map

iex> fetch_value(
...>   %{0 => %{field: "name", op: "==", value: "Joe"}},
...>   :name
...> )
{:ok, "Joe"}

iex> fetch_value(
...>   %{"0" => %{"field" => "name", "op" => "==", "value" => "Joe"}},
...>   :name
...> )
{:ok, "Joe"}

@spec get([t()] | [map()] | map(), atom()) :: t() | map() | nil

Returns the first filter for the given field.

Examples

Flop.Filter struct

iex> get([], :name)
nil

iex> get([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
%Flop.Filter{field: :name, op: :==, value: "Joe"}

iex> get([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
nil

iex> get(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
%Flop.Filter{field: :name, op: :==, value: "Joe"}

Map with atom keys

iex> get([%{field: :name, op: :==, value: "Joe"}], :name)
%{field: :name, op: :==, value: "Joe"}

Map with string keys

iex> get([%{"field" => "name", "op" => "==", "value" => "Joe"}], :name)
%{"field" => "name", "op" => "==", "value" => "Joe"}

iex> get([%{"field" => :name, "op" => "==", "value" => "Joe"}], :name)
%{"field" => :name, "op" => "==", "value" => "Joe"}

Indexed map

iex> get(
...>   %{0 => %{field: "name", op: "==", value: "Joe"}},
...>   :name
...> )
%{field: "name", op: "==", value: "Joe"}

iex> get(
...>   %{0 => %{field: :name, op: "==", value: "Joe"}},
...>   :name
...> )
%{field: :name, op: "==", value: "Joe"}

iex> get(
...>   %{"0" => %{"field" => "name", "op" => "==", "value" => "Joe"}},
...>   :name
...> )
%{"field" => "name", "op" => "==", "value" => "Joe"}

iex> get(
...>   %{"0" => %{"field" => :name, "op" => "==", "value" => "Joe"}},
...>   :name
...> )
%{"field" => :name, "op" => "==", "value" => "Joe"}

@spec get_all([t()] | [map()] | map(), atom()) :: [t()] | [map()]

Returns the all filters for the given field.

Examples

Flop.Filter struct

iex> get_all([], :name)
[]

iex> get_all([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
[%Flop.Filter{field: :name, op: :==, value: "Joe"}]

iex> get_all([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
[]

iex> get_all(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
[
  %Flop.Filter{field: :name, op: :==, value: "Joe"},
  %Flop.Filter{field: :name, op: :==, value: "Jim"}
]

Map with atom keys

iex> get_all(
...>   [
...>     %{field: :name, op: :==, value: "Joe"},
...>     %{field: :age, op: :>, value: 8},
...>     %{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
[
  %{field: :name, op: :==, value: "Joe"},
  %{field: :name, op: :==, value: "Jim"}
]

Map with string keys

iex> get_all(
...>   [
...>     %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     %{"field" => "age", "op" => ">", "value" => 8},
...>     %{"field" => "name", "op" => "==", "value" => "Jim"}
...>   ],
...>   :name
...> )
[
  %{"field" => "name", "op" => "==", "value" => "Joe"},
  %{"field" => "name", "op" => "==", "value" => "Jim"}
]

Indexed map

iex> get_all(
...>   %{
...>     0 => %{field: "name", op: "==", value: "Joe"},
...>     1 => %{field: "age", op: ">", value: 8},
...>     2 => %{field: "name", op: "==", value: "Jim"}
...>   },
...>   :name
...> )
[
  %{field: "name", op: "==", value: "Joe"},
  %{field: "name", op: "==", value: "Jim"}
]

iex> get_all(
...>   %{
...>     "0" => %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     "1" => %{"field" => "age", "op" => ">", "value" => 8},
...>     "2" => %{"field" => "name", "op" => "==", "value" => "Jim"}
...>   },
...>   :name
...> )
[
  %{"field" => "name", "op" => "==", "value" => "Joe"},
  %{"field" => "name", "op" => "==", "value" => "Jim"}
]

@spec get_value([t()] | [map()] | map(), atom()) :: any() | nil

Returns the first filter value for the given field.

Examples

Flop.Filter struct

iex> get_value([], :name)
nil

iex> get_value([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
"Joe"

iex> get_value([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
nil

iex> get_value(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"}
...>   ],
...>   :name
...> )
"Joe"

iex> get_value([%Flop.Filter{field: :ok, op: :empty, value: false}], :ok)
false

Map with atom keys

iex> get_value([%{field: :name, op: :==, value: "Joe"}], :name)
"Joe"

Map with string keys

iex> get_value(
...>   [%{"field" => "name", "op" => "==", "value" => "Joe"}],
...>   :name
...> )
"Joe"

Indexed map

iex> get_value(
...>   %{0 => %{field: "name", op: "==", value: "Joe"}},
...>   :name
...> )
"Joe"

iex> get_value(
...>   %{"0" => %{"field" => "name", "op" => "==", "value" => "Joe"}},
...>   :name
...> )
"Joe"

@spec new(
  Enumerable.t(),
  keyword()
) :: [t()]

Creates a list of filters from an enumerable.

The default operator is :==.

iex> filters = new(%{name: "George", age: 8})
iex> Enum.sort(filters)
[
  %Flop.Filter{field: :age, op: :==, value: 8},
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

iex> filters = new([name: "George", age: 8])
iex> Enum.sort(filters)
[
  %Flop.Filter{field: :age, op: :==, value: 8},
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

You can optionally pass a mapping from field names to operators as a map with atom keys.

iex> filters = new(
...>   %{name: "George", age: 8},
...>   operators: %{name: :ilike_and}
...> )
iex> Enum.sort(filters)
[
  %Flop.Filter{field: :age, op: :==, value: 8},
  %Flop.Filter{field: :name, op: :ilike_and, value: "George"}
]

You can also pass a map to rename fields.

iex> filters = new(
...>   %{s: "George", age: 8},
...>   rename: %{s: :name}
...> )
iex> Enum.sort(filters)
[
  %Flop.Filter{field: :age, op: :==, value: 8},
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

iex> filters = new(
...>   %{s: "George", cat: true},
...>   rename: %{s: :name, cat: :dog}
...> )
iex> Enum.sort(filters)
[
  %Flop.Filter{field: :dog, op: :==, value: true},
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

If both a rename option and an operator are set for a field, the operator option needs to use the new field name.

iex> new(
...>   %{n: "George"},
...>   rename: %{n: :name},
...>   operators: %{name: :ilike_or}
...> )
[%Flop.Filter{field: :name, op: :ilike_or, value: "George"}]

If the enumerable uses string keys as field names, the function attempts to convert them to existing atoms. If the atom does not exist, the filter is removed from the list.

iex> new(%{"name" => "George", "age" => 8})
[
  %Flop.Filter{field: :age, op: :==, value: 8},
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

iex> new(%{"name" => "George", "doesnotexist" => 8})
[
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

Other key types are also removed.

iex> new(%{"name" => "George", 2 => 8})
[
  %Flop.Filter{field: :name, op: :==, value: "George"}
]

@spec pop([t()] | [map()] | map(), atom(), any()) ::
  {t() | any(), [t()]} | {map() | any(), [map()]}

Returns the first filter for the given field and removes all other filters for the same field from the filter list.

Returns a tuple with the first matching filter for key and the remaining filter list. If there is no filter for the field in the list, the default value is returned as the first tuple element.

See also Flop.Filter.pop_first/3, Flop.Filter.pop_value/3 and Flop.Filter.pop_first_value/3.

Examples

Flop.Filter struct

iex> pop([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
{%Flop.Filter{field: :name, op: :==, value: "Joe"}, []}

iex> pop([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
{nil, [%Flop.Filter{field: :name, op: :==, value: "Joe"}]}

iex> pop(
...>   [%Flop.Filter{field: :name, op: :==, value: "Joe"}],
...>   :age,
...>   %Flop.Filter{field: :age, op: :>, value: 8}
...> )
{
  %Flop.Filter{field: :age, op: :>, value: 8},
  [%Flop.Filter{field: :name, op: :==, value: "Joe"}]
}

iex> pop(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"},
...>   ],
...>   :name
...> )
{
  %Flop.Filter{field: :name, op: :==, value: "Joe"},
  [%Flop.Filter{field: :age, op: :>, value: 8}]
}

Map with atom keys

iex> pop([%{field: :name, op: :==, value: "Joe"}], :name)
{%{field: :name, op: :==, value: "Joe"}, []}

Map with string keys

iex> pop([%{"field" => "name", "op" => "==", "value" => "Joe"}], :name)
{%{"field" => "name", "op" => "==", "value" => "Joe"}, []}

Indexed map

Filters passed as an indexed map will be converted to a list, even if no matching filter exists.

iex> pop(
...>   %{
...>     0 => %{field: "name", op: "==", value: "Joe"},
...>     1 => %{field: "age", op: ">", value: "8"},
...>     2 => %{field: "name", op: "==", value: "Jim"},
...>   },
...>   :name
...> )
{
  %{field: "name", op: "==", value: "Joe"},
  [%{field: "age", op: ">", value: "8"}]
}

iex> pop(
...>   %{
...>     0 => %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     1 => %{"field" => "age", "op" => ">", "value" => "8"},
...>     2 => %{"field" => "name", "op" => "==", "value" => "Jim"},
...>   },
...>   :name
...> )
{
  %{"field" => "name", "op" => "==", "value" => "Joe"},
  [%{"field" => "age", "op" => ">", "value" => "8"}]
}

@spec pop_first([t()] | [map()] | map(), atom(), any()) ::
  {t() | any(), [t()]} | {map() | any(), [map()]}

Returns the first filter for the given field and a filter list with all remaining filters.

Returns a tuple with the first matching filter for key and the remaining filter list. If there is no filter for the field in the list, the default value is returned as the first tuple element.

See also Flop.Filter.pop/3, Flop.Filter.pop_value/3 and Flop.Filter.pop_first_value/3.

Examples

Flop.Filter struct

iex> pop_first([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :name)
{%Flop.Filter{field: :name, op: :==, value: "Joe"}, []}

iex> pop_first([%Flop.Filter{field: :name, op: :==, value: "Joe"}], :age)
{nil, [%Flop.Filter{field: :name, op: :==, value: "Joe"}]}

iex> pop_first(
...>   [%Flop.Filter{field: :name, op: :==, value: "Joe"}],
...>   :age,
...>   %Flop.Filter{field: :age, op: :>, value: 8}
...> )
{
  %Flop.Filter{field: :age, op: :>, value: 8},
  [%Flop.Filter{field: :name, op: :==, value: "Joe"}]
}

iex> pop_first(
...>   [
...>     %Flop.Filter{field: :name, op: :==, value: "Joe"},
...>     %Flop.Filter{field: :age, op: :>, value: 8},
...>     %Flop.Filter{field: :name, op: :==, value: "Jim"},
...>   ],
...>   :name
...> )
{
  %Flop.Filter{field: :name, op: :==, value: "Joe"},
  [
    %Flop.Filter{field: :age, op: :>, value: 8},
    %Flop.Filter{field: :name, op: :==, value: "Jim"}
  ]
}

Map with atom keys

iex> pop_first([%{field: :name, op: :==, value: "Joe"}], :name)
{%{field: :name, op: :==, value: "Joe"}, []}

Map with string keys

iex> pop_first(
...>   [%{"field" => "name", "op" => "==", "value" => "Joe"}],
...>   :name
...> )
{%{"field" => "name", "op" => "==", "value" => "Joe"}, []}

Indexed map

Filters passed as an indexed map will be converted to a list, even if no matching filter exists.

iex> pop_first(
...>   %{
...>     0 => %{field: "name", op: "==", value: "Joe"},
...>     1 => %{field: "age", op: ">", value: 8},
...>     2 => %{field: "name", op: "==", value: "Jim"},
...>   },
...>   :name
...> )
{
  %{field: "name", op: "==", value: "Joe"},
  [
    %{field: "age", op: ">", value: 8},
    %{field: "name", op: "==", value: "Jim"}
  ]
}

iex> pop_first(
...>   %{
...>     "0" => %{"field" => "name", "op" => "==", "value" => "Joe"},
...>     "1" => %{"field" => "age", "op" => ">", "value" => 8},
...>     "2" => %{"field" => "name", "op" => "==", "value" => "Jim"},
...>   },
...>   :name
...> )
{
  %{"field" => "name", "op" => "==", "value" => "Joe"},
  [
    %{"field" => "age", "op" => ">", "value" => 8},
    %{"field" => "name", "op" => "==", "value" => "Jim"}
  ]
}