mtype.mli

(**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
(*                                                                        *)
(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

(* Operations on module types *)

open Types

val scrape: Env.t -> module_type -> module_type
        (* Expand toplevel module type abbreviations
           till hitting a "hard" module type (signature, functor,
           or abstract module type ident. *)
val scrape_alias: Env.t -> module_type -> module_type
        (* Expand toplevel module type abbreviations and aliases
           till hitting a "hard" module type (signature, functor,
           or abstract module type ident. *)
val reduce_lazy:
  Env.t -> Subst.Lazy.module_type -> Subst.Lazy.module_type option
val reduce: Env.t -> module_type -> module_type option
        (* Expand one toplevel module abbreviation. Return None if
           no expansion is possible. *)
val scrape_for_functor_arg: Env.t -> module_type -> module_type
        (* Remove aliases in a functor argument type *)
val scrape_for_type_of:
  remove_aliases:bool -> Env.t -> module_type -> module_type
        (* Process type for module type of *)
val freshen: scope:int -> module_type -> module_type
        (* Return an alpha-equivalent copy of the given module type
           where bound identifiers are fresh. *)
val strengthen_lazy:
        aliasable:bool -> Subst.Lazy.module_type -> Path.t -> Subst.Lazy.module_type
val strengthen: aliasable:bool -> module_type -> Path.t -> module_type
        (* Strengthen abstract type components relative to the
           given path. *)
val strengthen_lazy_decl:
  aliasable:bool -> Subst.Lazy.module_declaration -> Path.t -> Subst.Lazy.module_declaration
val strengthen_decl:
  aliasable:bool -> module_declaration -> Path.t -> module_declaration

val find_type_of_module:
  strengthen:bool -> aliasable:bool -> Env.t -> Path.t -> module_type
        (* Get the type of a module, strengthening if necessary. *)

val expand_to: Env.t -> signature -> Path.t list -> signature
        (* Expand Mty_strengthen nodes in a signature up to the
           given paths. *)

val sig_make_manifest : signature -> signature
        (* Make abstract types manifest.  Similar to strengthening, but rather
           than providing definitions by making the name of the current module
           explicit, simply create new identifiers with the same string part as
           the originals and assume they are defined in the context in which
           this signature appears.  *)

val nondep_supertype: Env.t -> Ident.t list -> module_type -> module_type
        (* Return the smallest supertype of the given type
           in which none of the given idents appears.
           @raise [Ctype.Nondep_cannot_erase] if no such type exists. *)

val nondep_sig: Env.t -> Ident.t list -> signature -> signature
        (* Return the signature with the types of its elements updated to be the
           smallest supertypes of their initial types in which none of the given
           ident appears.
           @raise [Ctype.Nondep_cannot_erase] if no such type exists. *)

val nondep_sig_item: Env.t -> Ident.t list -> signature_item -> signature_item
        (* Returns the signature item with its type updated
           to be the smallest supertype of its initial type
           in which none of the given idents appears.
           @raise [Ctype.Nondep_cannot_erase] if no such type exists. *)
val no_code_needed: Env.t -> module_type -> bool
val no_code_needed_sig: Env.t -> signature -> bool
        (* Determine whether a module needs no implementation code,
           i.e. consists only of type definitions. *)
val enrich_modtype: Env.t -> Path.t -> module_type -> module_type
val enrich_typedecl: Env.t -> Path.t -> Ident.t -> type_declaration ->
  type_declaration
val type_paths: Env.t -> Path.t -> module_type -> Path.t list
val contains_type: Env.t -> module_type -> bool
val lower_nongen: int -> module_type -> unit