Validixir.Validations (validixir v1.2.2)
This module contains premade validations for basic elixir types and often used functionality.
Link to this section Summary
Functions
Returns a validation success if the candidate is an atom, returns a failure otherwise.
Returns a validation success if the candidate is a binary, returns a failure otherwise.
Returns a validation success if the candidate is a bitstring, returns a failure otherwise.
Returns a validation success if the candidate is a boolean, returns a failure otherwise.
Returns a validation success if the candidate is an empty list, returns a failure otherwise.
Returns a validation success if the candidate is an exception, returns a failure otherwise.
Returns a validation success if the candidate is a float, returns a failure otherwise.
Returns a validation success if the candidate is a function, returns a failure otherwise.
Returns a validation success if the candidate is an integer, returns a failure otherwise.
Returns a validation success if the candidate is a list, returns a failure otherwise.
Returns a validation success if the candidate is a map, returns a failure otherwise.
Returns a validation success if the given map contains the given key, returns a failure otherwise.
Returns a validation success if the enum contains the elem, returns a failure otherwise.
Returns a validation success if the candidate is a negative integer, returns a failure otherwise.
Returns a validation success if the candidate is nil, returns a failure otherwise.
Since all other names are special words in elixir, we chose nil?
for the name of the function.
Returns a validation success if the candidate is a non-empty list, returns a failure otherwise.
Returns a validation success if the enum does not contain the elem, returns a failure otherwise.
Returns a validation success if the candidate is not nil, returns a failure otherwise.
Returns a validation success if the candidate is a number, returns a failure otherwise.
Returns a validation success if the candidate is a pid, returns a failure otherwise.
Returns a validation success if the candidate is a port, returns a failure otherwise.
Returns a validation success if the candidate is a positive integer, returns a failure otherwise.
Returns a validation success if the candidate is a reference, returns a failure otherwise.
Returns a validation success if the candidate is a struct, returns a failure otherwise.
Always returns a validation success.
Returns a validation success if the candidate is a tuple, returns a failure otherwise.
Link to this section Functions
atom(val)
@spec atom(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is an atom, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.atom(:hello)
{:ok, :hello}
iex> Validixir.Validations.atom(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_an_atom, context: Validixir.Validations}
],
__message_lookup: %{not_an_atom: true}
}}
binary(val)
@spec binary(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a binary, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.binary("foo")
{:ok, "foo"}
iex> Validixir.Validations.binary(<<1::3>>)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: <<1::3>>, message: :not_a_binary, context: Validixir.Validations}
],
__message_lookup: %{not_a_binary: true}
}}
bitstring(val)
@spec bitstring(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a bitstring, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.bitstring("foo")
{:ok, "foo"}
iex> Validixir.Validations.bitstring(<<1::3>>)
{:ok, <<1::3>>}
iex> Validixir.Validations.bitstring(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_a_bitstring, context: Validixir.Validations}
],
__message_lookup: %{not_a_bitstring: true}
}}
boolean(val)
@spec boolean(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a boolean, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.boolean(true)
{:ok, true}
iex> Validixir.Validations.boolean(nil)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: nil, message: :not_a_boolean, context: Validixir.Validations}
],
__message_lookup: %{not_a_boolean: true}
}}
empty_list(val)
@spec empty_list(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is an empty list, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.empty_list([])
{:ok, []}
iex> Validixir.Validations.empty_list([1,2,3])
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: [1,2,3], message: :not_an_empty_list, context: Validixir.Validations}
],
__message_lookup: %{not_an_empty_list: true}
}}
iex> Validixir.Validations.empty_list(%{})
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: %{}, message: :not_an_empty_list, context: Validixir.Validations}
],
__message_lookup: %{not_an_empty_list: true}
}}
exception(val)
@spec exception(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is an exception, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.exception(%RuntimeError{})
{:ok, %RuntimeError{}}
iex> Validixir.Validations.exception(%{})
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: %{}, message: :not_an_exception, context: Validixir.Validations}
],
__message_lookup: %{not_an_exception: true}
}}
float(val)
@spec float(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a float, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.float(12.2)
{:ok, 12.2}
iex> Validixir.Validations.float(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_a_float, context: Validixir.Validations}
],
__message_lookup: %{not_a_float: true}
}}
function(val)
@spec function(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a function, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.function(&Validixir.pure/1)
{:ok, &Validixir.pure/1}
iex> Validixir.Validations.function(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_a_function, context: Validixir.Validations}
],
__message_lookup: %{not_a_function: true}
}}
integer(val)
@spec integer(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is an integer, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.integer(12)
{:ok, 12}
iex> Validixir.Validations.integer(12.2)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12.2, message: :not_an_integer, context: Validixir.Validations}
],
__message_lookup: %{not_an_integer: true}
}}
list(val)
@spec list(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a list, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.list([1, 2, 3])
{:ok, [1,2,3]}
iex> Validixir.Validations.list([])
{:ok, []}
iex> Validixir.Validations.list(%{})
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: %{}, message: :not_a_list, context: Validixir.Validations}
],
__message_lookup: %{not_a_list: true}
}}
map(val)
@spec map(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a map, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.map(%{})
{:ok, %{}}
iex> person_struct = %Example.Person{name: "s", username: "h", email: "s@h.b", address: "s h b"}
iex> Validixir.Validations.map(person_struct)
{:ok, person_struct}
iex> Validixir.Validations.map([])
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: [], message: :not_a_map, context: Validixir.Validations}
],
__message_lookup: %{not_a_map: true}
}}
map_key(m, k)
@spec map_key(map(), any()) :: Validixir.validation_result_t(any())
Returns a validation success if the given map contains the given key, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.map_key(%{hello: :world}, :hello)
{:ok, {%{hello: :world}, :hello}}
iex> Validixir.Validations.map_key(%{}, :hello)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: {%{}, :hello}, message: :not_a_key_of_map, context: Validixir.Validations}
],
__message_lookup: %{not_a_key_of_map: true}
}}
member(enum, elem)
@spec member(Enum.t(), any()) :: Validixir.validation_result_t(any())
Returns a validation success if the enum contains the elem, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.member([1,2,3], 1)
{:ok, {[1,2,3], 1}}
iex> Validixir.Validations.member([], 1)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: {[], 1}, message: :not_a_member, context: Validixir.Validations}
],
__message_lookup: %{not_a_member: true}
}}
iex> Validixir.Validations.member([1,2,3], 12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: {[1,2,3], 12}, message: :not_a_member, context: Validixir.Validations}
],
__message_lookup: %{not_a_member: true}
}}
neg_integer(val)
@spec neg_integer(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a negative integer, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.neg_integer(-12)
{:ok, -12}
iex> Validixir.Validations.neg_integer(0)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 0, message: :not_a_negative_integer, context: Validixir.Validations}
],
__message_lookup: %{not_a_negative_integer: true}
}}
iex> Validixir.Validations.neg_integer(2)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 2, message: :not_a_negative_integer, context: Validixir.Validations}
],
__message_lookup: %{not_a_negative_integer: true}
}}
nil?(val)
@spec nil?(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is nil, returns a failure otherwise.
Since all other names are special words in elixir, we chose nil?
for the name of the function.
examples
Examples
iex> Validixir.Validations.nil?(nil)
{:ok, nil}
iex> Validixir.Validations.nil?(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_nil, context: Validixir.Validations}
],
__message_lookup: %{not_nil: true}
}}
non_empty_list(val)
@spec non_empty_list(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a non-empty list, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.non_empty_list([1,2,3])
{:ok, [1,2,3]}
iex> Validixir.Validations.non_empty_list([])
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: [], message: :not_a_non_empty_list, context: Validixir.Validations}
],
__message_lookup: %{not_a_non_empty_list: true}
}}
iex> Validixir.Validations.non_empty_list(%{})
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: %{}, message: :not_a_non_empty_list, context: Validixir.Validations}
],
__message_lookup: %{not_a_non_empty_list: true}
}}
not_a_member(enum, elem)
@spec not_a_member(Enum.t(), any()) :: Validixir.validation_result_t(any())
Returns a validation success if the enum does not contain the elem, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.not_a_member([1,2,3], 4)
{:ok, {[1,2,3], 4}}
iex> Validixir.Validations.not_a_member([], 1)
{:ok, {[], 1}}
iex> Validixir.Validations.not_a_member([1,2,3], 1)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: {[1,2,3], 1}, message: :is_a_member, context: Validixir.Validations}
],
__message_lookup: %{is_a_member: true}
}}
not_nil(val)
@spec not_nil(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is not nil, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.not_nil(12)
{:ok, 12}
iex> Validixir.Validations.not_nil(nil)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: nil, message: :is_nil, context: Validixir.Validations}
],
__message_lookup: %{is_nil: true}
}}
number(val)
@spec number(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a number, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.number(12.2)
{:ok, 12.2}
iex> Validixir.Validations.number(12)
{:ok, 12}
iex> Validixir.Validations.number(nil)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: nil, message: :not_a_number, context: Validixir.Validations}
],
__message_lookup: %{not_a_number: true}
}}
pid(val)
@spec pid(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a pid, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.pid(self())
{:ok, self()}
iex> Validixir.Validations.pid(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_a_pid, context: Validixir.Validations}
],
__message_lookup: %{not_a_pid: true}
}}
port(val)
@spec port(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a port, returns a failure otherwise.
pos_integer(val)
@spec pos_integer(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a positive integer, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.pos_integer(12)
{:ok, 12}
iex> Validixir.Validations.pos_integer(0)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 0, message: :not_a_positive_integer, context: Validixir.Validations}
],
__message_lookup: %{not_a_positive_integer: true}
}}
iex> Validixir.Validations.pos_integer(-2)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: -2, message: :not_a_positive_integer, context: Validixir.Validations}
],
__message_lookup: %{not_a_positive_integer: true}
}}
reference(val)
@spec reference(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a reference, returns a failure otherwise.
examples
Examples
iex> ref = make_ref()
iex> Validixir.Validations.reference(ref)
{:ok, ref}
iex> Validixir.Validations.reference(12)
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: 12, message: :not_a_reference, context: Validixir.Validations}
],
__message_lookup: %{not_a_reference: true}
}}
struct(val)
@spec struct(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a struct, returns a failure otherwise.
examples
Examples
iex> person_struct = %Example.Person{name: "s", username: "h", email: "s@h.b", address: "s h b"}
iex> Validixir.Validations.struct(person_struct)
{:ok, person_struct}
iex> Validixir.Validations.struct(%{})
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: %{}, message: :not_a_struct, context: Validixir.Validations}
],
__message_lookup: %{not_a_struct: true}
}}
succeed(candidate)
@spec succeed(Validixir.Success.some_inner_t()) :: Validixir.Success.t(Validixir.Success.some_inner_t())
Always returns a validation success.
examples
Examples
iex> Validixir.Validations.succeed(12)
{:ok, 12}
tuple(val)
@spec tuple(any()) :: Validixir.validation_result_t(any())
Returns a validation success if the candidate is a tuple, returns a failure otherwise.
examples
Examples
iex> Validixir.Validations.tuple({1,2,3})
{:ok, {1,2,3}}
iex> Validixir.Validations.tuple([1,2,3])
{:error, %Validixir.Failure{errors: [
%Validixir.Error{candidate: [1,2,3], message: :not_a_tuple, context: Validixir.Validations}
],
__message_lookup: %{not_a_tuple: true}
}}