ValidatorOf

A closure type that encapsulates validation logic.

The validate function. Call this as a function to perform validation on a given value.

Initialises an instance with the given Validator closure.

Swift’s trailing closure syntax allows for validator types to be defined quite succinctly:

let myIntValidator = ValidatorOf<Int, String> { value in
    // your validation logic here
}

Returns a new validator derived from self that operates on values of type LocalValue.

Validator pullback allows you to re-use existing validator logic that works on one type A against a different type B by providing a function that knows how to transform type B to A.

For example, say you have an ageValidator that operates on type Int, a struct Person that has an age: Int property and you want to define a personValidator that validates the person’s age.

Instead of writing a validator from scratch, you can simply use your existing ageValidator, pulled back to operate on type Person, providing a function that returns Person.age:

let personValidator: ValidatorOf<Person, String> = ageValidator.pullback { person in person.age }

Since Swift 5.2 allows you to pass a KeyPath as a function, the you can pass in any KeyPath<LocalValue, Value> instead:

let personValidator: ValidatorOf<Person, String> = ageValidator.pullback(\.age)

Returns a new optional validator that operates on Value? instead of Value.

This operator allows you to re-use an existing validator on non-optional types with an optional of the same type.

This can be useful in situations where you cannot rely on the Swift type system to enforce optional behaviour, for example if you are capturing some user input that you require be non-nil but cannot use a non-optional type as there is no sensible default that you can use.

Whenever possible, if you have a value that is required and you are able to provide a sensible default you should prefer to use the Swift type system to enforce it and use a non-optional property and validator.

This generic form takes an optional error value that will be used to determine if a value is required in order to be valid.

Returns a validator that is the logical inverse of self.

If you have some validator that performs some kind of boolean logic, you can easily produce a negated version using this operator.

Example:

let isTrue = ValidatorOf<Bool, String> {
    if $0 == true { return .valid(true) }
    return .error("must be true")
}

let isFalse = isTrue.negated(withError: "must be false")

Returns a new validator whose errors are transformed by the provided closure.

This operator can be used to modify or replace errors on an existing validator whilst not changing the actual validation logic itself.

All validators that produce an invalid result will hold on to a non-empty array of errors although many will typically only have one error. In this case you can simply return a brand new error value from your transform closure and it will replace that single error.

However, it is possible for a validator to hold more than one error, for instance, any validators that you have composed using combine. In this case, you should use this method to derive a new error from the existing one. If you need to replace all errors with a single error you should use reduceErrors instead.

Composes multiple validators into a single validator.

This form takes a variadic list of validators/

Composes an array of validators into a single validator.

Returns a new validator that accumulates the results of each composed validator, returning a .valid result if all validators are valid or an .invalid result containing an aggregate of all errors if any of them are invalid.

Validates that a boolean value is true.

Validates that a boolean value is false.

Validates the collection’s count against the given numeric validator.

This validator allows you to flexibly validate the collection count using any other Int validator, for example:

.hasLengthOf(.greaterThan(1))

Validates the collection’s count is exactly the given value.

This validator is a convenience and is equivalent to passing .isExactly(count) to hasLengthOf(validator:).

Validate that the collection contains the given element.

Validates that a value >= the given value.

Validates that a value is <= the given value.

Validates that a value is < the given value.

Validates that a value is > the given value.

Validates that a value is within the given range.

Validates that a value is within the given range.

Validates that a value is in a given collection.

This validation makes it possible to validate that a value is one of a given list of values.

Validates that a value is not in a given collection.

This validation makes it possible to validate that a value is not one of a given list of values.

Validates that a value is in a given collection.

This validation makes it possible to validate that a value is one of a given list of values.

Validates that a value is not in a given collection.

This validation makes it possible to validate that a value is not one of a given list of values.

Validates that value is equal to another value.

Validates that the value is exactly the given amount.

This validator is effectively the same as isEqualTo but with a slightly modified error message.

Validates that a value is even.

Validates that a value is odd.

Validates that a string starts with a given prefix.

Validates that a string ends with a given suffix.

Validates that the string’s length matches the given numeric validator.

Validates that the string’s length is equal to the given length.

This is shorthand for .itsLength(.isExactly(length)).

Validates that a string matches the given pattern.

This allows you to validate a string against a regular expression or any other supported string comparison type.

Validates that string is an empty string (i.e. "").

Validates that a string is non-empty.

Returns a new optional validator that operates on Value? instead of Value.

This operator allows you to re-use an existing validator on non-optional types with an optional of the same type.

This operator is similar to optional(errorOnNil:) except instead of taking an error value, it simply takes a boolean to indicate whether nil is allowed. If allowNil is true then nil values will be treated as valid, otherwise they will be treated as invalid, using a default string error message.

Whilst you could use mapErrors or reduceErrors to modify the default message, if you need to use a specific error you should use optional(errorOnNil:) and pass the required error directly.