# Module Validate

    module Validate: sig .. end

A module for organizing validations of data structures. Allows standardized ways of checking for conditions, and keeps track of the location of errors by keeping a path to each error found. Thus, if you were validating the following datastructure:

          { foo = 3;
            bar = { snoo = 34.5;
                    blue = Snoot -6; }
          }

One might end up with an error with the error path:

    bar.blue.Snoot : value -6 <= bound 0

By convention, the validations for a type defined in module `M` appear in module `M`, and have their name prefixed by `validate_`. E.g. `Int.validate_positive`.

Here's an example of how you would use validate with a record.

         type t =
           { foo: int;
             bar: float;
           }
         with fields

         let validate t =
           let module V = Validate in
           let w check = V.field_folder t check in
           V.of_list
             (Fields.fold ~init:[]
                ~foo:(w Int.validate_positive)
                ~bar:(w Float.validate_non_negative)
             )

And here's an example of how you would use it with a variant type:

          type t =
            | Foo of int
            | Bar of (float * int)
            | Snoo of Floogle.t

          let validate = function
            | Foo i -> V.name "Foo" (Int.validate_positive i)
            | Bar p -> V.name "Bar" (V.pair
                                       ~fst:Float.validate_positive
                                       ~snd:Int.validate_non_negative)
            | Snoo floogle -> V.name "Snoo" Floogle.validate

    type t

The result of a validation. This effectively contains the list of errors, qualified by their location path

    type 'a check = 'a -> t

to make function signatures easier to read

    val pass : t

A result containing no errors

    val fail : string -> t

A result containing a single error

    val fails : string -> 'a -> ('a -> Sexplib.Sexp.t) -> t

    val failf : ('a, unit, string, t) Pervasives.format4 -> 'a

Like `sprintf` or `failwithf` but produces a `t` instead of a string or exception

    val of_list : t list -> t

combine multiple results, merging errors

    val name : string -> t -> t

extend location path by one name

    val name_list : string -> t list -> t

    val fail_fn : string -> 'a check

`fail_fn err` returns a function that always returns fail, with `err` as the error message. (Note that there is no `pass_fn` so as to discourage people from ignoring the type of the value being passed unconditionally irrespective of type.)

    val pass_bool : bool check

Check for unconditionally passing a bool

    val pass_unit : unit check

Check for unconditionally passing a unit

    val protect : 'a check -> 'a check

`protect f x` applies the validation `f` to `x`, catching any exceptions and returning them as errors.

    val result : t -> unit Or_error.t

    val errors : t -> string list

Returns a list of formatted error strings, which include both the error message and the path to the error.

    val maybe_raise : t -> unit

If the result contains any errors, then raises an exception with a formatted error message containing a message for every error.

    val valid_or_error : 'a -> 'a check -> 'a Or_error.t

Returns an error if validation fails.

    val field : 'record -> ('record, 'a) Fieldslib.Field.t -> 'a check -> t

Used for validating an individual field.

    val field_folder : 'record ->
           'a check ->
           t list -> ('record, 'a) Fieldslib.Field.t -> t list

Creates a function for use in a `Fields.fold`.

    val all : 'a check list -> 'a check

Combine a list of validation functions into one that does all validations.

    val of_result : ('a -> (unit, string) Result.t) -> 'a check

Create a validation function from a function that produces a Result.t

    val of_error : ('a -> unit Or_error.t) -> 'a check

    val booltest : ('a -> bool) -> if_false:string -> 'a check

Create a validation function from a function that produces a bool

    val pair : fst:'a check -> snd:'b check -> ('a * 'b) check

Validation functions for particular data types.

    val list_indexed : 'a check -> 'a list check

Validates a list, naming each element by its position in the list (where the first position is 1, not 0)

    val list : name:('a -> string) -> 'a check -> 'a list check

Validates a list, naming each element using a user-defined function for computing the name

    val first_failure : t -> t -> t

    val of_error_opt : string option -> t

    val alist : name:('a -> string) -> 'b check -> ('a * 'b) list check

Validates an association list, naming each element using a user-defined function for computing the name.