sig
  module Monitor :
    sig
      module Tail :
        sig
          module Deferred :
            sig
              type ('a, 'execution_context) t =
                  ('a, 'execution_context) Raw_deferred.t
              type ('a, 'execution_context) deferred =
                  ('a, 'execution_context) t
              val of_ivar :
                ('a, 'execution_context) Raw_ivar.t ->
                ('a, 'execution_context) t
              val create :
                (('a, 'execution_context) Raw_ivar.t -> unit) ->
                ('a, 'execution_context) t
              val peek : ('a, 'b) t -> 'a option
              val is_determined : ('a, 'b) t -> bool
              val return : 'a -> ('a, 'b) t
              module Scheduler_dependent :
                functor (Scheduler : Import.Basic_scheduler) ->
                  sig
                    type 'a t = ('a, Scheduler.Execution_context.t) deferred
                    val sexp_of_t :
                      ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    type 'a detailed = 'a t
                    val sexp_of_detailed :
                      ('a -> Sexplib.Sexp.t) -> 'a detailed -> Sexplib.Sexp.t
                    val upon : 'a t -> ('a -> unit) -> unit
                    val upon' : 'a t -> ('a -> unit) -> Unregister.t
                    val bind : 'a t -> ('a -> 'b t) -> 'b t
                    val install_removable_handler :
                      'a t ->
                      ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                      Unregister.t
                  end
              val ounit_tests : unit -> OUnit.test
            end
          module Ivar :
            sig
              module Handler :
                sig
                  type ('a, 'execution_context) t =
                      ('a, 'execution_context) Raw_ivar.Handler.t
                end
              type ('a, 'execution_context) t =
                  ('a, 'execution_context) Raw_ivar.t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) ->
                ('execution_context -> Sexplib.Sexp.t) ->
                ('a, 'execution_context) t -> Sexplib.Sexp.t
              type ('a, 'execution_context) ivar = ('a, 'execution_context) t
              val equal : ('a, 'b) t -> ('a, 'b) t -> bool
              val create : unit -> ('a, 'b) t
              val create_full : 'a -> ('a, 'b) t
              val peek : ('a, 'b) t -> 'a option
              val is_empty : ('a, 'b) t -> bool
              val is_full : ('a, 'b) t -> bool
              module Scheduler_dependent :
                functor (Scheduler : Import.Basic_scheduler) ->
                  sig
                    type 'a t = ('a, Scheduler.Execution_context.t) ivar
                    val sexp_of_t :
                      ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    type 'a detailed = 'a t
                    val sexp_of_detailed :
                      ('a -> Sexplib.Sexp.t) -> 'a detailed -> Sexplib.Sexp.t
                    val connect : bind_result:'a t -> bind_rhs:'a t -> unit
                    val fill : 'a t -> 'a -> unit
                    val install_removable_handler :
                      'a t ->
                      ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                      Unregister.t
                    val upon : 'a t -> ('a -> unit) -> unit
                    val upon' : 'a t -> ('a -> unit) -> Unregister.t
                  end
              val debug_space_leaks : int option ref
              val ounit_tests : unit -> OUnit.test
            end
          module Stream :
            sig
              module Deferred :
                sig
                  type ('a, 'execution_context) t =
                      ('a, 'execution_context) Raw_deferred.t
                  type ('a, 'execution_context) deferred =
                      ('a, 'execution_context) t
                  val of_ivar :
                    ('a, 'execution_context) Raw_ivar.t ->
                    ('a, 'execution_context) t
                  val create :
                    (('a, 'execution_context) Raw_ivar.t -> unit) ->
                    ('a, 'execution_context) t
                  val peek : ('a, 'b) t -> 'a option
                  val is_determined : ('a, 'b) t -> bool
                  val return : 'a -> ('a, 'b) t
                  module Scheduler_dependent :
                    functor (Scheduler : Import.Basic_scheduler) ->
                      sig
                        type 'a t =
                            ('a, Scheduler.Execution_context.t) deferred
                        val sexp_of_t :
                          ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        type 'a detailed = 'a t
                        val sexp_of_detailed :
                          ('a -> Sexplib.Sexp.t) ->
                          'a detailed -> Sexplib.Sexp.t
                        val upon : 'a t -> ('a -> unit) -> unit
                        val upon' : 'a t -> ('a -> unit) -> Unregister.t
                        val bind : 'a t -> ('a -> 'b t) -> 'b t
                        val install_removable_handler :
                          'a t ->
                          ('a, Scheduler.Execution_context.t) Raw_handler.t ->
                          Unregister.t
                      end
                  val ounit_tests : unit -> OUnit.test
                end
              type ('a, 'execution_context) t =
                  (('a, 'execution_context) next, 'execution_context)
                  Deferred.t
              and ('a, 'execution_context) next =
                ('a, 'execution_context) Raw_stream.next =
                  Nil
                | Cons of 'a * ('a, 'execution_context) t
              val next : 'a -> 'a
              val sexp_of_t :
                ('a -> Core.Std.Sexp.t) ->
                'b -> (('a, 'c) next, 'c) Deferred.t -> Core.Std.Sexp.t
              val ounit_tests : unit -> OUnit.test
            end
          type ('a, 'execution_context) t =
            ('a, 'execution_context) Raw_tail.t = {
            mutable next :
              (('a, 'execution_context) Stream.next, 'execution_context)
              Ivar.t;
          }
          val sexp_of_t : 'a -> 'b -> ('c, 'd) t -> Core.Std.Sexp.t
          val create : unit -> ('a, 'b) t
          val collect : ('a, 'b) t -> (('a, 'b) Stream.next, 'b) Deferred.t
          val ounit_tests : unit -> OUnit.test
        end
      type 'execution_context t =
        'execution_context Raw_monitor.t = {
        name_opt : string option;
        id : int;
        parent : 'execution_context t option;
        errors : (exn, 'execution_context) Tail.t;
        mutable has_seen_error : bool;
        mutable someone_is_listening : bool;
      }
      val someone_is_listening : 'a t -> bool
      val set_someone_is_listening : 'a t -> bool -> unit
      val has_seen_error : 'a t -> bool
      val set_has_seen_error : 'a t -> bool -> unit
      val errors : 'a t -> (exn, 'a) Tail.t
      val parent : 'a t -> 'a t option
      val id : 'a t -> int
      val name_opt : 'a t -> string option
      module Fields :
        sig
          val names : string list
          val someone_is_listening : ('a t, bool) Fieldslib.Field.t
          val has_seen_error : ('a t, bool) Fieldslib.Field.t
          val errors :
            ('execution_context t, (exn, 'execution_context) Tail.t)
            Fieldslib.Field.t
          val parent :
            ('execution_context t, 'execution_context t option)
            Fieldslib.Field.t
          val id : ('a t, int) Fieldslib.Field.t
          val name_opt : ('a t, string option) Fieldslib.Field.t
          val make_creator :
            name_opt:(('a t, string option) Fieldslib.Field.t ->
                      'b -> ('c -> string option) * 'd) ->
            id:(('e t, int) Fieldslib.Field.t -> 'd -> ('c -> int) * 'f) ->
            parent:(('g t, 'g t option) Fieldslib.Field.t ->
                    'f -> ('c -> 'h t option) * 'i) ->
            errors:(('j t, (exn, 'j) Tail.t) Fieldslib.Field.t ->
                    'i -> ('c -> (exn, 'h) Tail.t) * 'k) ->
            has_seen_error:(('l t, bool) Fieldslib.Field.t ->
                            'k -> ('c -> bool) * 'm) ->
            someone_is_listening:(('n t, bool) Fieldslib.Field.t ->
                                  'm -> ('c -> bool) * 'o) ->
            'b -> ('c -> 'h t) * 'o
          val create :
            name_opt:string option ->
            id:int ->
            parent:'a t option ->
            errors:(exn, 'a) Tail.t ->
            has_seen_error:bool -> someone_is_listening:bool -> 'a t
          val iter :
            name_opt:(('a t, string option) Fieldslib.Field.t -> unit) ->
            id:(('b t, int) Fieldslib.Field.t -> unit) ->
            parent:(('c t, 'c t option) Fieldslib.Field.t -> unit) ->
            errors:(('d t, (exn, 'd) Tail.t) Fieldslib.Field.t -> unit) ->
            has_seen_error:(('e t, bool) Fieldslib.Field.t -> unit) ->
            someone_is_listening:(('f t, bool) Fieldslib.Field.t -> 'g) -> 'g
          val fold :
            init:'a ->
            name_opt:('a -> ('b t, string option) Fieldslib.Field.t -> 'c) ->
            id:('c -> ('d t, int) Fieldslib.Field.t -> 'e) ->
            parent:('e -> ('f t, 'f t option) Fieldslib.Field.t -> 'g) ->
            errors:('g -> ('h t, (exn, 'h) Tail.t) Fieldslib.Field.t -> 'i) ->
            has_seen_error:('i -> ('j t, bool) Fieldslib.Field.t -> 'k) ->
            someone_is_listening:('k -> ('l t, bool) Fieldslib.Field.t -> 'm) ->
            'm
          val map :
            name_opt:(('a t, string option) Fieldslib.Field.t ->
                      string option) ->
            id:(('b t, int) Fieldslib.Field.t -> int) ->
            parent:(('c t, 'c t option) Fieldslib.Field.t -> 'd t option) ->
            errors:(('e t, (exn, 'e) Tail.t) Fieldslib.Field.t ->
                    (exn, 'd) Tail.t) ->
            has_seen_error:(('f t, bool) Fieldslib.Field.t -> bool) ->
            someone_is_listening:(('g t, bool) Fieldslib.Field.t -> bool) ->
            'd t
          val map_poly : ('a t, 'b) Fieldslib.Field.user -> 'b list
          val for_all :
            name_opt:(('a t, string option) Fieldslib.Field.t -> bool) ->
            id:(('b t, int) Fieldslib.Field.t -> bool) ->
            parent:(('c t, 'c t option) Fieldslib.Field.t -> bool) ->
            errors:(('d t, (exn, 'd) Tail.t) Fieldslib.Field.t -> bool) ->
            has_seen_error:(('e t, bool) Fieldslib.Field.t -> bool) ->
            someone_is_listening:(('f t, bool) Fieldslib.Field.t -> bool) ->
            bool
          val exists :
            name_opt:(('a t, string option) Fieldslib.Field.t -> bool) ->
            id:(('b t, int) Fieldslib.Field.t -> bool) ->
            parent:(('c t, 'c t option) Fieldslib.Field.t -> bool) ->
            errors:(('d t, (exn, 'd) Tail.t) Fieldslib.Field.t -> bool) ->
            has_seen_error:(('e t, bool) Fieldslib.Field.t -> bool) ->
            someone_is_listening:(('f t, bool) Fieldslib.Field.t -> bool) ->
            bool
          val to_list :
            name_opt:(('a t, string option) Fieldslib.Field.t -> 'b) ->
            id:(('c t, int) Fieldslib.Field.t -> 'b) ->
            parent:(('d t, 'd t option) Fieldslib.Field.t -> 'b) ->
            errors:(('e t, (exn, 'e) Tail.t) Fieldslib.Field.t -> 'b) ->
            has_seen_error:(('f t, bool) Fieldslib.Field.t -> 'b) ->
            someone_is_listening:(('g t, bool) Fieldslib.Field.t -> 'b) ->
            'b list
          module Direct :
            sig
              val iter :
                'a t ->
                name_opt:(('b t, string option) Fieldslib.Field.t ->
                          'a t -> string option -> unit) ->
                id:(('c t, int) Fieldslib.Field.t -> 'a t -> int -> unit) ->
                parent:(('d t, 'd t option) Fieldslib.Field.t ->
                        'a t -> 'a t option -> unit) ->
                errors:(('e t, (exn, 'e) Tail.t) Fieldslib.Field.t ->
                        'a t -> (exn, 'a) Tail.t -> unit) ->
                has_seen_error:(('f t, bool) Fieldslib.Field.t ->
                                'a t -> bool -> unit) ->
                someone_is_listening:(('g t, bool) Fieldslib.Field.t ->
                                      'a t -> bool -> 'h) ->
                'h
              val fold :
                'a t ->
                init:'b ->
                name_opt:('b ->
                          ('c t, string option) Fieldslib.Field.t ->
                          'a t -> string option -> 'd) ->
                id:('d -> ('e t, int) Fieldslib.Field.t -> 'a t -> int -> 'f) ->
                parent:('f ->
                        ('g t, 'g t option) Fieldslib.Field.t ->
                        'a t -> 'a t option -> 'h) ->
                errors:('h ->
                        ('i t, (exn, 'i) Tail.t) Fieldslib.Field.t ->
                        'a t -> (exn, 'a) Tail.t -> 'j) ->
                has_seen_error:('j ->
                                ('k t, bool) Fieldslib.Field.t ->
                                'a t -> bool -> 'l) ->
                someone_is_listening:('l ->
                                      ('m t, bool) Fieldslib.Field.t ->
                                      'a t -> bool -> 'n) ->
                'n
            end
        end
      val bogus : unit -> 'a t
      module Pretty :
        sig
          type one =
            Raw_monitor.Pretty.one = {
            name_opt : string option;
            id : int;
            has_seen_error : bool;
            someone_is_listening : bool;
          }
          val sexp_of_one : one -> Sexplib.Sexp.t
          type t = one list
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      val to_pretty : 'a t -> Pretty.one Core.Std.List.t
      val sexp_of_t : 'a -> 'b t -> Sexplib.Sexp.t
      exception Shutdown
      val ounit_tests : unit -> OUnit.test
    end
  type t =
    Execution_context.t = {
    block_group : Block_group.t;
    monitor : t Monitor.t;
    priority : Priority.t;
    backtrace_history : Core.Std.Backtrace.t list;
  }
  val sexp_of_t : t -> Sexplib.Sexp.t
  val backtrace_history : t -> Core.Std.Backtrace.t list
  val priority : t -> Priority.t
  val monitor : t -> t Monitor.t
  val block_group : t -> Block_group.t
  module Fields :
    sig
      val names : string list
      val backtrace_history :
        (t, Core.Std.Backtrace.t list) Fieldslib.Field.t
      val priority : (t, Priority.t) Fieldslib.Field.t
      val monitor : (t, t Monitor.t) Fieldslib.Field.t
      val block_group : (t, Block_group.t) Fieldslib.Field.t
      val make_creator :
        block_group:((t, Block_group.t) Fieldslib.Field.t ->
                     'a -> ('b -> Block_group.t) * 'c) ->
        monitor:((t, t Monitor.t) Fieldslib.Field.t ->
                 'c -> ('b -> t Monitor.t) * 'd) ->
        priority:((t, Priority.t) Fieldslib.Field.t ->
                  'd -> ('b -> Priority.t) * 'e) ->
        backtrace_history:((t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           'e -> ('b -> Core.Std.Backtrace.t list) * 'f) ->
        'a -> ('b -> t) * 'f
      val create :
        block_group:Block_group.t ->
        monitor:t Monitor.t ->
        priority:Priority.t ->
        backtrace_history:Core.Std.Backtrace.t list -> t
      val iter :
        block_group:((t, Block_group.t) Fieldslib.Field.t -> unit) ->
        monitor:((t, t Monitor.t) Fieldslib.Field.t -> unit) ->
        priority:((t, Priority.t) Fieldslib.Field.t -> unit) ->
        backtrace_history:((t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           'a) ->
        'a
      val fold :
        init:'a ->
        block_group:('a -> (t, Block_group.t) Fieldslib.Field.t -> 'b) ->
        monitor:('b -> (t, t Monitor.t) Fieldslib.Field.t -> 'c) ->
        priority:('c -> (t, Priority.t) Fieldslib.Field.t -> 'd) ->
        backtrace_history:('d ->
                           (t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           'e) ->
        'e
      val map :
        block_group:((t, Block_group.t) Fieldslib.Field.t -> Block_group.t) ->
        monitor:((t, t Monitor.t) Fieldslib.Field.t -> t Monitor.t) ->
        priority:((t, Priority.t) Fieldslib.Field.t -> Priority.t) ->
        backtrace_history:((t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           Core.Std.Backtrace.t list) ->
        t
      val map_poly : (t, 'a) Fieldslib.Field.user -> 'a list
      val for_all :
        block_group:((t, Block_group.t) Fieldslib.Field.t -> bool) ->
        monitor:((t, t Monitor.t) Fieldslib.Field.t -> bool) ->
        priority:((t, Priority.t) Fieldslib.Field.t -> bool) ->
        backtrace_history:((t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           bool) ->
        bool
      val exists :
        block_group:((t, Block_group.t) Fieldslib.Field.t -> bool) ->
        monitor:((t, t Monitor.t) Fieldslib.Field.t -> bool) ->
        priority:((t, Priority.t) Fieldslib.Field.t -> bool) ->
        backtrace_history:((t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           bool) ->
        bool
      val to_list :
        block_group:((t, Block_group.t) Fieldslib.Field.t -> 'a) ->
        monitor:((t, t Monitor.t) Fieldslib.Field.t -> 'a) ->
        priority:((t, Priority.t) Fieldslib.Field.t -> 'a) ->
        backtrace_history:((t, Core.Std.Backtrace.t list) Fieldslib.Field.t ->
                           'a) ->
        'a list
      module Direct :
        sig
          val iter :
            t ->
            block_group:((t, Block_group.t) Fieldslib.Field.t ->
                         t -> Block_group.t -> unit) ->
            monitor:((t, t Monitor.t) Fieldslib.Field.t ->
                     t -> t Monitor.t -> unit) ->
            priority:((t, Priority.t) Fieldslib.Field.t ->
                      t -> Priority.t -> unit) ->
            backtrace_history:((t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t ->
                               t -> Core.Std.Backtrace.t list -> 'a) ->
            'a
          val fold :
            t ->
            init:'a ->
            block_group:('a ->
                         (t, Block_group.t) Fieldslib.Field.t ->
                         t -> Block_group.t -> 'b) ->
            monitor:('b ->
                     (t, t Monitor.t) Fieldslib.Field.t ->
                     t -> t Monitor.t -> 'c) ->
            priority:('c ->
                      (t, Priority.t) Fieldslib.Field.t ->
                      t -> Priority.t -> 'd) ->
            backtrace_history:('d ->
                               (t, Core.Std.Backtrace.t list)
                               Fieldslib.Field.t ->
                               t -> Core.Std.Backtrace.t list -> 'e) ->
            'e
        end
    end
  val bogus : t
  val create_like :
    ?block_group:Block_group.t ->
    ?monitor:t Monitor.t -> ?priority:Priority.t -> t -> t
  val record_backtrace : t -> t
  val ounit_tests : unit -> OUnit.test
end