package coq

  1. Overview
  2. Docs
package coq
Legend:
Library
Module
Module type
Parameter
Class
Class type

Lib: record of operations, backtrack, low-level sections

This module provides a general mechanism to keep a trace of all operations and to backtrack (undo) those operations. It provides also the section mechanism (at a low level; discharge is not known at this step).

type is_type = bool
type export_flag =
  1. | Export
  2. | Import
type export = (export_flag * Libobject.open_filter) option
val make_foname : Names.Id.t -> Libobject.object_name
type node =
  1. | CompilingLibrary of Nametab.object_prefix
  2. | OpenedModule of is_type * export * Nametab.object_prefix * Summary.frozen
  3. | OpenedSection of Nametab.object_prefix * Summary.frozen
val node_prefix : node -> Nametab.object_prefix

Extract the object_prefix component. Note that it is the prefix of the objects *inside* this node, eg in Module M. we have OpenedModule with prefix containing M.

type library_segment = (node * Libobject.t list) list
type classified_objects = {
  1. substobjs : Libobject.t list;
  2. keepobjs : Libobject.t list;
  3. anticipateobjs : Libobject.t list;
}
...

Low-level adding operations (does not cache)

val add_entry : node -> unit
val add_leaf_entry : Libobject.t -> unit
...

Adding operations (which call the cache method, and getting the current list of operations (most recent ones coming first).

val add_leaf : Libobject.obj -> unit
...

The function contents gives access to the current entire segment

val contents : unit -> library_segment
Functions relative to current path
val prefix : unit -> Nametab.object_prefix

User-side names

val cwd : unit -> Names.DirPath.t
val cwd_except_section : unit -> Names.DirPath.t
val current_dirpath : bool -> Names.DirPath.t
val make_path : Names.Id.t -> Libnames.full_path
val make_path_except_section : Names.Id.t -> Libnames.full_path
val current_mp : unit -> Names.ModPath.t

Kernel-side names

val make_kn : Names.Id.t -> Names.KerName.t
val sections_are_opened : unit -> bool

Are we inside an opened section

  • deprecated Use Global.sections_are_opened
val sections_depth : unit -> int
val is_module_or_modtype : unit -> bool

Are we inside an opened module type

val is_modtype : unit -> bool
val is_modtype_strict : unit -> bool
val is_module : unit -> bool
val find_opening_node : Names.Id.t -> node

Returns the opening node of a given name

Modules and module types
Compilation units
val start_compilation : Names.DirPath.t -> Names.ModPath.t -> unit
val library_dp : unit -> Names.DirPath.t

The function library_dp returns the DirPath.t of the current compiling library (or default_library)

Extract the library part of a name even if in a section

val split_modpath : Names.ModPath.t -> Names.DirPath.t * Names.Id.t list
val library_part : Names.GlobRef.t -> Names.DirPath.t
Sections
val open_section : Names.Id.t -> unit
val close_section : unit -> unit
We can get and set the state of the operations (used in States).
type frozen
val freeze : unit -> frozen
val unfreeze : frozen -> unit
val drop_objects : frozen -> frozen

Keep only the libobject structure, not the objects themselves

val init : unit -> unit
val section_segment_of_constant : Names.Constant.t -> Cooking.cooking_info

Section management for discharge

val section_segment_of_inductive : Names.MutInd.t -> Cooking.cooking_info
val section_segment_of_reference : Names.GlobRef.t -> Cooking.cooking_info
val section_instance : Names.GlobRef.t -> Constr.t array
val is_in_section : Names.GlobRef.t -> bool
Discharge: decrease the section level if in the current section