Validation Module

Input Validation Framework for Suave

Types and nested modules

Type/Module Description

Collection

Compare

DateTime

Numeric

Parse

String

AsyncValidator<'T, 'U>

Async validator type

ValidationError

Represents a validation error for a specific field

ValidationResult<'T>

Result of a validation operation

Validator<'T, 'U>

A validator that transforms input of type 'T to output of type 'U

Functions and values

Function or value Description

(<++>)

Full Usage: (<++>)

Returns: Validator<'a, 'b> -> Validator<'a, 'b> -> Validator<'a, 'b>

Infix operator for andAlso (<++>)

Returns: Validator<'a, 'b> -> Validator<'a, 'b> -> Validator<'a, 'b>

()

Full Usage: ()

Returns: Validator<'a, 'b> -> Validator<'a, 'b> -> Validator<'a, 'b>

Infix operator for orElse ()

Returns: Validator<'a, 'b> -> Validator<'a, 'b> -> Validator<'a, 'b>

f <@> x

Full Usage: f <@> x

Parameters:
Returns: Validator<'a, 'c>

Infix operator for apply (<@>)

f : Validator<'a, ('b -> 'c)>
x : Validator<'a, 'b>
Returns: Validator<'a, 'c>

(<^>)

Full Usage: (<^>)

Returns: ('a -> 'b) -> Validator<'c, 'a> -> Validator<'c, 'b>

Infix operator for map (<^>)

Returns: ('a -> 'b) -> Validator<'c, 'a> -> Validator<'c, 'b>

(>=>)

Full Usage: (>=>)

Returns: ('a -> Validator<'b, 'c>) -> Validator<'b, 'a> -> Validator<'b, 'c>

Infix operator for bind (>=>)

Returns: ('a -> Validator<'b, 'c>) -> Validator<'b, 'a> -> Validator<'b, 'c>

andAlso validator2 validator1 input

Full Usage: andAlso validator2 validator1 input

Parameters:
Returns: ValidationResult<'U>

Compose two validators (passes input through both, collecting all errors)

validator2 : Validator<'T, 'U>
validator1 : Validator<'T, 'U>
input : 'T
Returns: ValidationResult<'U>

apply validatorF validatorX input

Full Usage: apply validatorF validatorX input

Parameters:
Returns: ValidationResult<'V>

Apply a validator that returns a function to a validator that returns a value

validatorF : Validator<'T, ('U -> 'V)>
validatorX : Validator<'T, 'U>
input : 'T
Returns: ValidationResult<'V>

bind f validator input

Full Usage: bind f validator input

Parameters:
Returns: ValidationResult<'V>

Bind validators sequentially (stop on first error)

f : 'U -> Validator<'T, 'V>
validator : Validator<'T, 'U>
input : 'T
Returns: ValidationResult<'V>

bindAsync f validator input

Full Usage: bindAsync f validator input

Parameters:
Returns: Async<ValidationResult<'V>>

Bind async validators

f : 'U -> AsyncValidator<'T, 'V>
validator : AsyncValidator<'T, 'U>
input : 'T
Returns: Async<ValidationResult<'V>>

custom predicate field message input

Full Usage: custom predicate field message input

Parameters:
    predicate : 'T -> bool
    field : string
    message : string
    input : 'T

Returns: ValidationResult<'T>

Create a custom validator with a predicate function

predicate : 'T -> bool
field : string
message : string
input : 'T
Returns: ValidationResult<'T>

customWithError f input

Full Usage: customWithError f input

Parameters:
Returns: ValidationResult<'U>

Create a custom validator that can return a specific error

f : 'T -> Choice<'U, ValidationError>
input : 'T
Returns: ValidationResult<'U>

error field message code

Full Usage: error field message code

Parameters:
    field : string
    message : string
    code : string option

Returns: ValidationError

Create a validation error

field : string
message : string
code : string option
Returns: ValidationError

errorSimple field message

Full Usage: errorSimple field message

Parameters:
    field : string
    message : string

Returns: ValidationError

Create a simple validation error without a code

field : string
message : string
Returns: ValidationError

fail err arg2

Full Usage: fail err arg2

Parameters:
Returns: ValidationResult<'U>

Create a validator that always fails

err : ValidationError
arg1 : 'T
Returns: ValidationResult<'U>

list validator input

Full Usage: list validator input

Parameters:
    validator : Validator<'T, 'U>
    input : 'T list

Returns: ValidationResult<'U list>

Validate a list of items

validator : Validator<'T, 'U>
input : 'T list
Returns: ValidationResult<'U list>

map f validator input

Full Usage: map f validator input

Parameters:
    f : 'U -> 'V
    validator : Validator<'T, 'U>
    input : 'T

Returns: ValidationResult<'V>

Map over a valid value

f : 'U -> 'V
validator : Validator<'T, 'U>
input : 'T
Returns: ValidationResult<'V>

mapAsync f validator input

Full Usage: mapAsync f validator input

Parameters:
Returns: Async<ValidationResult<'V>>

Map over async validator

f : 'U -> 'V
validator : AsyncValidator<'T, 'U>
input : 'T
Returns: Async<ValidationResult<'V>>

optional validator input

Full Usage: optional validator input

Parameters:
    validator : Validator<'T, 'U>
    input : 'T option

Returns: ValidationResult<'U option>

Make a validator optional (None is always valid)

validator : Validator<'T, 'U>
input : 'T option
Returns: ValidationResult<'U option>

orElse validator2 validator1 input

Full Usage: orElse validator2 validator1 input

Parameters:
Returns: ValidationResult<'U>

Try first validator, if it fails try second

validator2 : Validator<'T, 'U>
validator1 : Validator<'T, 'U>
input : 'T
Returns: ValidationResult<'U>

succeed value arg2

Full Usage: succeed value arg2

Parameters:
    value : 'U
    arg1 : 'T

Returns: ValidationResult<'U>

Create a validator that always succeeds

value : 'U
arg1 : 'T
Returns: ValidationResult<'U>

toAsync validator input

Full Usage: toAsync validator input

Parameters:
Returns: Async<ValidationResult<'U>>

Convert sync validator to async

validator : Validator<'T, 'U>
input : 'T
Returns: Async<ValidationResult<'U>>