The init system is the part of RNT responsible from taking a description of what a live system should look like and instantiating a system that matches this description, constructing and connecting different components as necessary. It is not a supervisor, that is, it is not responsible for maintaining the state of the system once it has been built, although it provides functionality that could support the implementation of a supervisor.

More concretely, the role of the init system is to build a *system* out of a set of *components*. *Components* are the description of a building block of systems that can either require *services* from an existing component, extend an existing component and provide services to other components. A component that extends another component implicitly requires that component. Components, through this provision and requirement relationship, form a directed acyclic graph. Concretely, a component might look something like this:

#+begin_src ocaml
type service = ..

type component =
  { provides: service BatSet.t;
    requires: service BatSet.t;
    (* extends: extension list; *)
    construct: (service, Handle.t) BatMap.t -> (Handle.t, Concepts.Condition.condition) result }



module type SUBSYSTEM = struct
  type t
  val create : unit -> t
  val destroy : t -> unit
end

module MySubsystem : SUBSYSTEM = struct

end



type ('a, 'b) service = ..

type ('a, 'b) service += ServiceThatTakesAnInt
let makeServiceThatTakesAnInt : int service = ServiceThatTakesAnInt

type ('a, 'b) extension = ('a, 'b) service * ('a -> ('b, Concepts.Condition.condition) result)

type component =
  { provides: service;
    extends: extension BatSet.t
    extend: ()}

let _ = Component.make
	      ~provides:MySubsystem
          ~extends:[extend Subsystem (fun h ->
                        MySubsystem.make <><>)]

let _ = Component.make
	      ~requires:[SubsystemRegistry]
          ~provides:[MySubsystem]
          ~mount:(fun h ->
            let myself = MySubstystem.make <><> in
            SubssystemRegistry.register myself;
            myself)
          ~unmount:(fun h myself ->
            Lifecycle.destroy myself)

(* options:
   - object destroy itself on unmount through lifecycles
     - would require us to be able to notify the owner, which would mean we have to know who the owner is
 ,*)



type component =
  { ex}
#+end_src