package lambdapi
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=d01e5f13db2eaba6e4fe330667149e0059d4886c651ff9d6b672db2dfc9765ed
sha512=33b68c972aca37985ed73c527076198e7d4961c7e27c89cdabfe4d1cff97cd41ccfb85ae9499eb98ad9a0aefd920bc55555df6393fc441ac2429e4d99cddafa8
doc/lambdapi.core/Core/Sign/index.html
Module Core.Sign
Source
Signature for symbols.
type ind_data = {
ind_cons : Term.sym list;
(*Constructors.
*)ind_prop : Term.sym;
(*Induction principle.
*)ind_nb_params : int;
(*Number of parameters.
*)ind_nb_types : int;
(*Number of mutually defined types.
*)ind_nb_cons : int;
(*Number of constructors.
*)
}
Data associated to inductive type symbols.
The priority of an infix operator is a floating-point number.
type 'a notation =
| Prefix of 'a
| Postfix of 'a
| Infix of Pratter.associativity * 'a
| Zero
| Succ of 'a notation option
| Quant
| PosOne
| PosDouble
| PosSuccDouble
| IntZero
| IntPos
| IntNeg
Notations.
type t = {
sign_symbols : Term.sym Lplib.Extra.StrMap.t Timed.ref;
sign_path : Common.Path.t;
sign_deps : Term.rule list Lplib.Extra.StrMap.t Common.Path.Map.t Timed.ref;
(*Maps a path to a list of pairs (symbol name, rule).
*)sign_builtins : Term.sym Lplib.Extra.StrMap.t Timed.ref;
sign_notations : float notation Term.SymMap.t Timed.ref;
(*Maps symbols to their notation if they have some.
*)sign_ind : ind_data Term.SymMap.t Timed.ref;
sign_cp_pos : Term.cp_pos list Term.SymMap.t Timed.ref;
(*Maps a symbol to the critical pair positions it is heading in the rules.
*)
}
Representation of a signature. It roughly corresponds to a set of symbols, defined in a single module (or file).
The empty signature. WARNING: to be used for creating ghost signatures only. Use Sig_state functions otherwise. It's a thunk to force the creation of a new record on each call (and avoid unwanted sharing).
find sign name
finds the symbol named name
in sign
if it exists, and raises the Not_found
exception otherwise.
loaded
stores the signatures of the known (already compiled or currently being compiled) modules. An important invariant is that all occurrences of a symbol are physically equal, even across signatures). This is ensured by making copies of terms when loading an object file.
find_sym path name
returns the symbol identified by path
and name
in the known modules (already compiled or currently being compiled)
loading
contains the modules that are being processed. They are stored in a stack due to dependencies. Note that the topmost element corresponds to the current module. If a module appears twice in the stack, then there is a circular dependency.
current_path ()
returns the current signature path.
unlink sign
removes references to external symbols (and thus signatures) in the signature sign
. This function is used to minimize the size of object files, by preventing a recursive inclusion of all the dependencies. Note however that unlink
processes sign
in place, which means that the signature is invalidated in the process.
val add_symbol :
t ->
Term.expo ->
Term.prop ->
Term.match_strat ->
bool ->
Common.Pos.strloc ->
Common.Pos.popt ->
Term.term ->
bool list ->
Term.sym
add_symbol sign expo prop mstrat opaq name pos typ impl
adds in the signature sign
a symbol with name name
, exposition expo
, property prop
, matching strategy strat
, opacity opaq
, type typ
, implicit arguments impl
, no definition and no rules. name
should not already be used in sign
. pos
is the position of the declaration (without its definition). The created symbol is returned.
add_rule sign sym r
adds the new rule r
to the symbol sym
. When the rule does not correspond to a symbol of signature sign
, it is stored in its dependencies. /!\ does not update the decision tree or the critical pairs.
add_rules sign sym rs
adds the new rules rs
to the symbol sym
. When the rules do not correspond to a symbol of signature sign
, they are stored in its dependencies. /!\ does not update the decision tree or the critical pairs.
update_notation n
provides an update function for n
to be used with Map.S.update
.
add_notation sign s n
sets notation of s
to n
in sign
.
val add_notation_from_builtin :
string ->
Term.sym ->
'a notation Term.SymMap.t ->
'a notation Term.SymMap.t
add_notation_from_builtin builtin sym notation_map
adds in notation_map
the notation required when builtin
is mapped to sym
.
add_builtin sign name sym
binds the builtin name name
to sym
(in the signature sign
). The previous binding, if any, is discarded.
add_inductive sign ind_sym ind_cons ind_prop ind_prop_args
add to sign
the inductive type ind_sym
with constructors ind_cons
, induction principle ind_prop
with ind_prop_args
arguments.
iterate f sign
applies f
on sign
and its dependencies recursively.
dependencies sign
returns an association list containing (the transitive closure of) the dependencies of the signature sign
. Note that the order of the list gives one possible loading order for the signatures. Note also that sign
itself appears at the end of the list.