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 = valid.all([
	valid.string_is_not_empty("Empty"),
	valid.string_min_length(">=3", 3),
	valid.string_max_length("<=10", 10)
])

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

Compose validators

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

Example

let name_validator = valid.string_is_not_empty("Empty")
|> valid.and(valid.string_min_length("Must be at least six", 6))

Build a validator for a type that has one attribute

Example

type Person { Person(name: String) }

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

Build a validator for a type that has two attributes

Example

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

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

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) {
	valid.build3(person)
	|> valid.check(person.name, name_validator)
	|> valid.check(person.age, ...)
	|> valid.check(person.email, ...)
}

Build a validator for a type that has four attributes

Build a validator for a type that has five attributes

Build a validator for a type that has six attributes

Validate an attribute.

Example

let validator = fn(person: Person) {
	valid.build1(Person)
	|> valid.check(person.name, valid.string_is_not_empty(ErrorEmpty))
}

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) {
	valid.build1(Person)
	|> valid.check(person.name, valid.custom("Not Sam", must_be_sam))
}

Validate that a value is not None. Returns the value if Some.

Example

type PersonInput { PersonInput(name: Option(String)) }

type PersonValid { PersonValid(name: String) }

let validator = fn(person) {
	valid.build1(PersonValid)
	|> valid.check(person.name, valid.is_some("Name is null"))
}

Keep a value as is.

Example

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

Validate a list of items.

Run the given validator for each item returning all the errors.

Example

type Collection = { Collection(items: List(String) ) }

let list_validator = valid.list_every(
	valid.string_min_length("Must be at least 3", 3)
)

let validator = fn(collection: Collection) {
	valid.build1(Collection)
	|> valid.check(collection.items, list_validator)
}

Validate that a list is not empty

Validate the max number of items in a list

Validate the min number of items in a list

A validator that always succeeds

Validate an optional value.

Run the validator only if the value is Some. If the value is None then return None back.

Example

type PersonValid{ PersonValid(name: Option(String)) }

let validator = fn(person) {
	valid.build1(PersonValid)
	|> valid.check(
		person.name,
		valid.optional(valid.string_min_length("Short", 3))
	)
}

Validate an attribute required in an arbitrary data type Here you provide your own accessor The accessor should return Option(property)

Example

let get_name = fn(d) { dict.get(d, “name”) |> option.from_result }

let validator = fn(dictionary: Dict(String, String)) {
	valid.build1(Person)
	|> valid.check_required(
from: dictionary,
get: get_name,
missing: "Missing name",
validator: valid.string_is_not_empty(ErrorEmpty)

) }

Validate an attribute required in a dictionary If you have a dictionary instead of a custom type, use this.

Example

let validator = fn(dictionary: Dict(String, String)) {
	valid.build1(Person)
	|> valid.check_required_in_dict(
from: dictionary,
get: "name",
missing: "Missing name",
validator: valid.string_is_not_empty(ErrorEmpty)

) }

Validate if a string is an email.

This checks if a string follows a simple pattern _@_.

Validate if a string parses to an Float. Returns the Float if so.

Validate if a string parses to an Int. Returns the Int if so.

Validate if a string is not empty

Validate the max length of a string

Validate the min length of a string

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) {
	valid.build2(Character)
	|> valid.check(c.level, valid.int_min("Level must be more that zero", 1))
	|> valid.check(c.strength, valid.int_min("Strength must be more that zero", 1))
	|> valid.whole(strengh_and_level_validator)
}