module Validate:sig
..end
{ 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
type'a
check ='a -> t
val pass : t
val fail : string -> t
val fails : string -> 'a -> ('a -> Sexplib.Sexp.t) -> t
val failf : ('a, unit, string, t) Pervasives.format4 -> 'a
sprintf
or failwithf
but produces a t
instead of a string or exceptionval of_list : t list -> t
val name : string -> t -> t
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
val pass_unit : unit check
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
val maybe_raise : t -> unit
val valid_or_error : 'a -> 'a check -> 'a Or_error.t
val field : 'record -> ('record, 'a) Fieldslib.Field.t -> 'a check -> t
val field_folder : 'record ->
'a check ->
t list -> ('record, 'a) Fieldslib.Field.t -> t list
Fields.fold
.val all : 'a check list -> 'a check
val of_result : ('a -> (unit, string) Result.t) -> 'a check
val of_error : ('a -> unit Or_error.t) -> 'a check
val booltest : ('a -> bool) -> if_false:string -> 'a check
val pair : fst:'a check -> snd:'b check -> ('a * 'b) check
val list_indexed : 'a check -> 'a list check
val list : name:('a -> string) -> 'a check -> 'a list check
val first_failure : t -> t -> t
val of_error_opt : string option -> t
val alist : name:('a -> string) -> 'b check -> ('a * 'b) list check