Module Async_kernel__.Async_invariant.Async

type 'a t = 'a Async_kernel__.Async_invariant_intf.Async.t
module type S = Async_kernel__.Async_invariant_intf.Async.S
module type S1 = Async_kernel__.Async_invariant_intf.Async.S1
module type S2 = Async_kernel__.Async_invariant_intf.Async.S2
module type S3 = Async_kernel__.Async_invariant_intf.Async.S3
val invariant : Core_kernel.Source_code_position.t ‑> 'a ‑> ('a ‑> Core_kernel.Sexp.t) ‑> (unit ‑> unit Async_kernel.Deferred.t) ‑> unit Async_kernel.Deferred.t
val check_field : 'a ‑> 'b t ‑> unit Async_kernel.Deferred.t ‑> ('a, 'b) Core_kernel.Field.t ‑> unit Async_kernel.Deferred.t

check_field can be used to check record fields when using [@@deriving fields]. Idiomatic usage looks like:

          type t = { foo : Foo.t ; bar : Bar.t }
          [@@deriving fields]

          let invariant t =
            Invariant.Async.invariant [%here] t [%sexp_of: t] (fun () ->
              let check inv = Invariant.Async.check_field t inv in
              Fields.fold ~init:(return ())
                ~foo: (check Foo.invariant)
                ~bar: (check Bar.invariant)

When some fields have synchronous invariants, or do not need to be checked, it may be useful to define a second wrapper around check_field:

          type t = { foo : Foo.t ; bar : Bar.t ; quux : Quux.t }
          [@@deriving fields]

          let invariant t =
            Invariant.Async.invariant [%here] t [%sexp_of: t] (fun () ->
              let check' inv = Invariant.Async.check_field t inv in
              let check inv = check' (fun x -> inv x; return ()) in
              Fields.fold ~init:(return ())
                ~foo:  (check' Foo.invariant)
                ~bar:  (check  Bar.invariant)
                ~quux: (check  ignore)