valid - v0.4.0

valid

Functions

all

</> 
pub fn all(
  validators: List(fn(a) -> Result(a, #(b, List(b)))),
) -> fn(a) -> Result(a, #(b, List(b)))

Validate a value using a list of validators. This runs all the validators in the list.

The initial input is passed to all validators. All these validators must have the same input and output types.

Returns Ok when all validators pass. Returns Error when any validator fails. Error will have all failures.

Example

let name_validator = v.all([
	v_string.is_not_empty("Empty"),
	v_string.min_length(">=3", 3),
	v_string.max_length("<=10", 10)
])

let validator = fn(person: Person) {
	v.build1(person)
	|> v.validate(person.name, name_validator)
}

and

</> 
pub fn and(
  validator1: fn(a) -> Result(b, #(c, List(c))),
  validator2: fn(b) -> Result(d, #(c, List(c))),
) -> fn(a) -> Result(d, #(c, List(c)))

Compose validators

Run the first validator and if successful then the second. Only returns the first error.

Example

let name_validator = v_string.is_not_empty("Empty")
|> v.and(v_string.min_length("Must be at least six", 6))

build1

</> 
pub fn build1(constructor: a) -> Result(a, b)

Build a validator for a type that has one attribute

Example

type Person { Person(name: String) }

let validator = fn(person: Person) {
	v.build1(person)
	|> v.validate(person.name, name_validator)
}

build2

</> 
pub fn build2(
  constructor: fn(a, b) -> c,
) -> Result(fn(a) -> fn(b) -> c, d)

Build a validator for a type that has two attributes

Example

type Person { Person(name: String, age: Int) }

let validator = fn(person: Person) {
	v.build2(person)
	|> v.validate(person.name, name_validator)
	|> v.validate(person.age, ...)
}

build3

</> 
pub fn build3(
  constructor: fn(a, b, c) -> d,
) -> Result(fn(a) -> fn(b) -> fn(c) -> d, e)

Build a validator for a type that has three attributes

Example

type Person { Person(name: String, age: Int, email: String) }

let validator = fn(person: Person) {
	v.build3(person)
	|> v.validate(person.name, name_validator)
	|> v.validate(person.age, ...)
	|> v.validate(person.email, ...)
}

build4

</> 
pub fn build4(
  constructor: fn(a, b, c, d) -> e,
) -> Result(fn(a) -> fn(b) -> fn(c) -> fn(d) -> e, f)

Build a validator for a type that has four attributes

build5

</> 
pub fn build5(
  constructor: fn(a, b, c, d, e) -> f,
) -> Result(fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> f, g)

Build a validator for a type that has five attributes

build6

</> 
pub fn build6(
  constructor: fn(a, b, c, d, e, f) -> g,
) -> Result(
  fn(a) -> fn(b) -> fn(c) -> fn(d) -> fn(e) -> fn(f) -> g,
  h,
)

Build a validator for a type that has six attributes

custom

</> 
pub fn custom(
  error: a,
  check: fn(b) -> Option(c),
) -> fn(b) -> Result(c, #(a, List(a)))

Create a custom validator

A custom validator has two attributes:

  • The error
  • A check function

The check function is a function that takes an input and returns Option(output)

Example

let must_be_sam = fn(name: String) -> Option(String) {
	case name == "Sam" {
		True -> Some(name)
		False -> None
	}
}

let validator = fn(person: Person) {
	v.build1(Person)
	|> v.validate(person.name, v.custom("Not Sam", must_be_sam))
}

keep

</> 
pub fn keep(
  accumulator: Result(fn(a) -> b, #(c, List(c))),
  value: a,
) -> Result(b, #(c, List(c)))

Keep a value as is.

Example

fn person_validor(person: Person) {
	v.build2(Person)
		|> v.validate(person.name, ...)
		|> v.keep(person.age)
}

validate

</> 
pub fn validate(
  accumulator: Result(fn(a) -> b, #(c, List(c))),
  value: d,
  validator: fn(d) -> Result(a, #(c, List(c))),
) -> Result(b, #(c, List(c)))

Validate an attribute.

Example

let validator = fn(person: Person) {
	v.build1(Person)
	|> v.validate(person.name, v_string.is_not_empty(ErrorEmpty))
}

whole

</> 
pub fn whole(
  validator: fn(a) -> Result(a, b),
) -> fn(Result(a, #(b, List(b)))) -> Result(a, #(b, List(b)))

Validate a structure as a whole.

Sometimes we need to validate a property in relation to another.

This function requires a check function like:

fn(a) -> Result(a, error)

Example

let strengh_and_level_validator = fn(c: Character) {
	case c.level > c.strength {
		True -> Error(error)
		False -> Ok(c)
	}
}

let validator = fn(c: Character) {
	v.build2(Character)
	|> v.validate(c.level, v_int.min("Level must be more that zero", 1))
	|> v.validate(c.strength, v_int.min("Strength must be more that zero", 1))
	|> v.whole(strengh_and_level_validator)
}
✨ Search Document