functor
  (X : sig
         type t = int
         val eq : t -> t -> bool
         val to_string : t -> string
         val compare : t -> t -> int
       end) ->
  sig
    module Presentation :
      sig
        module W :
          sig
            type t = X.t array
            type word = t
            val mul : t -> t -> t
            val one : t
            val inj : X.t -> t
            val length : t -> int
            val sub : t -> int -> int -> t
            val eq : t -> t -> bool
            val compare : t -> t -> int
            val peq : t -> int -> t -> int -> int -> bool
            val to_string : t -> string
            val included : t -> t -> bool
            val unifier : ?i:int -> t -> t -> int
            val ordered_unifiers : t -> t -> int list
            val ordered_unifiers_bicontext :
              t -> t -> ((t * t) * (t * t)) list
            val unifiers_bicontext : t -> t -> ((t * t) * (t * t)) list
            module Order :
              sig
                val lexicographic : (X.t -> X.t -> bool) -> t -> t -> bool
                val deglex : (X.t -> X.t -> bool) -> t -> t -> bool
              end
            module Anick :
              sig
                type t = word list
                val empty : t
                val singleton : X.t -> t
                val singletons : X.t list -> t list
                val hd : t -> word
                val tl : t -> t
                val weq : t -> t -> bool
                val eq : t list -> t list -> bool
                val compare : t list -> t list -> int
                val extend : word list -> t list -> t list
                val eval : t -> t
                val length : t -> int
                val to_string : t -> string
              end
          end
        type t =
          Presentation(X).t = {
          generators : X.t list;
          rules : (W.t * W.t) list;
        }
        val make : X.t list -> (W.t * W.t) list -> t
        val orient : (W.t -> W.t -> bool) -> t -> t
        val normalize : t -> W.t -> W.t
        val add_rule : t -> W.t * W.t -> t
        val reduce : t -> t
        val complete : (W.t -> W.t -> bool) -> t -> t
        module Make :
          functor (P : sig val presentation : t end) ->
            sig
              type t = Presentation(X).Make(P).t
              val eq : t -> t -> bool
              val mul : t -> t -> t
              val one : t
              val to_string : t -> string
              val compare : t -> t -> int
            end
      end
    val intset : int -> int list
  end