sig
  module Sequential :
    sig
      val compute :
        worker:('a -> 'b) ->
        master:('a * 'c -> 'b -> ('a * 'c) list) -> ('a * 'c) list -> unit
      val map : f:('a -> 'b) -> 'a list -> 'b list
      val map_local_fold :
        f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
      val map_remote_fold :
        f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
      val map_fold_ac :
        f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b
      val map_fold_a :
        f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b
    end
  module Cores :
    sig
      val set_number_of_cores : int -> unit
      val compute :
        worker:('a -> 'b) ->
        master:('a * 'c -> 'b -> ('a * 'c) list) -> ('a * 'c) list -> unit
      val map : f:('a -> 'b) -> 'a list -> 'b list
      val map_local_fold :
        f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
      val map_remote_fold :
        f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
      val map_fold_ac :
        f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b
      val map_fold_a :
        f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b
    end
  module Network :
    sig
      type worker
      val create_worker : ?port:int -> string -> Functory.Network.worker
      val declare_workers : ?port:int -> ?n:int -> string -> unit
      val set_default_port_number : int -> unit
      val set_pong_timeout : float -> unit
      val set_ping_interval : float -> unit
      type worker_type = ?port:int -> unit -> unit
      type computation_status = Running | Done | Dead
      module Same :
        sig
          module Computation :
            sig
              type ('a, 'c) t
              val create :
                worker:('a -> 'b) ->
                master:('a * 'c -> 'b -> ('a * 'c) list) ->
                ('a, 'c) Functory.Network.Same.Computation.t
              val add_worker :
                ('a, 'c) Functory.Network.Same.Computation.t ->
                Functory.Network.worker -> unit
              val add_task :
                ('a, 'c) Functory.Network.Same.Computation.t ->
                'a * 'c -> unit
              val remove_worker :
                ('a, 'c) Functory.Network.Same.Computation.t ->
                Functory.Network.worker -> unit
              val one_step :
                ?timeout:float ->
                ('a, 'c) Functory.Network.Same.Computation.t -> unit
              val status :
                ('a, 'c) Functory.Network.Same.Computation.t ->
                Functory.Network.computation_status
              val clear :
                ('a, 'c) Functory.Network.Same.Computation.t -> unit
              val kill : ('a, 'c) Functory.Network.Same.Computation.t -> unit
            end
          val compute :
            worker:('a -> 'b) ->
            master:('a * 'c -> 'b -> ('a * 'c) list) ->
            ('a * 'c) list -> unit
          module Worker : sig val compute : Functory.Network.worker_type end
          val map : f:('a -> 'b) -> 'a list -> 'b list
          val map_local_fold :
            f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
          val map_remote_fold :
            f:('a -> 'b) -> fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
          val map_fold_ac :
            f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b
          val map_fold_a :
            f:('a -> 'b) -> fold:('b -> 'b -> 'b) -> 'b -> 'a list -> 'b
        end
      module Poly :
        sig
          module Master :
            sig
              module Computation :
                sig
                  type ('a, 'c) t
                  val create :
                    master:('a * 'c -> 'b -> ('a * 'c) list) ->
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t
                  val add_worker :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    Functory.Network.worker -> unit
                  val remove_worker :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    Functory.Network.worker -> unit
                  val one_step :
                    ?timeout:float ->
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    unit
                  val status :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    Functory.Network.computation_status
                  val kill :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    unit
                  val clear :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    unit
                  val add_task :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    'a * 'c -> unit
                  val nb_tasks :
                    ('a, 'c) Functory.Network.Poly.Master.Computation.t ->
                    int
                end
              val compute :
                master:('a * 'c -> 'b -> ('a * 'c) list) ->
                ('a * 'c) list -> unit
              val map : 'a list -> 'b list
              val map_local_fold :
                fold:('c -> 'b -> 'c) -> 'c -> 'a list -> 'c
              val map_remote_fold : 'c -> 'a list -> 'c
              val map_fold_ac : 'b -> 'a list -> 'b
              val map_fold_a : 'b -> 'a list -> 'b
            end
          module Worker :
            sig
              val compute : ('a -> 'b) -> Functory.Network.worker_type
              val map : f:('a -> 'b) -> Functory.Network.worker_type
              val map_local_fold :
                f:('a -> 'b) -> Functory.Network.worker_type
              val map_remote_fold :
                f:('a -> 'b) ->
                fold:('c -> 'b -> 'c) -> Functory.Network.worker_type
              val map_fold_ac :
                f:('a -> 'b) ->
                fold:('b -> 'b -> 'b) -> Functory.Network.worker_type
              val map_fold_a :
                f:('a -> 'b) ->
                fold:('b -> 'b -> 'b) -> Functory.Network.worker_type
            end
        end
      module Mono :
        sig
          module Computation :
            sig
              type 'c t
              val create :
                master:(string * 'c -> string -> (string * 'c) list) ->
                'c Functory.Network.Mono.Computation.t
              val add_worker :
                'c Functory.Network.Mono.Computation.t ->
                Functory.Network.worker -> unit
              val remove_worker :
                'c Functory.Network.Mono.Computation.t ->
                Functory.Network.worker -> unit
              val one_step :
                ?timeout:float ->
                'c Functory.Network.Mono.Computation.t -> unit
              val status :
                'c Functory.Network.Mono.Computation.t ->
                Functory.Network.computation_status
              val kill : 'c Functory.Network.Mono.Computation.t -> unit
              val clear : 'c Functory.Network.Mono.Computation.t -> unit
              val add_task :
                'c Functory.Network.Mono.Computation.t -> string * 'c -> unit
            end
          module Master :
            sig
              val compute :
                master:(string * 'c -> string -> (string * 'c) list) ->
                (string * 'c) list -> unit
            end
          module Worker :
            sig
              val compute :
                (string -> string) -> Functory.Network.worker_type
            end
        end
    end
  module Control : sig val set_debug : bool -> unit end
end