Context.Rel
Representation of contexts that can capture anonymous as well as non-anonymous variables. Individual declarations are then designated by de Bruijn indexes.
module Declaration : sig ... end
type ('constr, 'types) pt = ('constr, 'types) Declaration.pt list
Rel-context is represented as a list of declarations. Inner-most declarations are at the beginning of the list. Outer-most declarations are at the end of the list.
val empty : ('c, 't) pt
empty rel-context
val add : ('c, 't) Declaration.pt -> ('c, 't) pt -> ('c, 't) pt
Return a new rel-context enriched by with a given inner-most declaration.
val length : ('c, 't) pt -> int
Return the number of local declarations in a given rel-context.
Check whether given two rel-contexts are equal.
val nhyps : ('c, 't) pt -> int
Return the number of local assumptions in a given rel-context.
val lookup : int -> ('c, 't) pt -> ('c, 't) Declaration.pt
Return a declaration designated by a given de Bruijn index.
Map all terms in a given rel-context taking into account the position of the binder in the context starting at 1.
val iter : ('c -> unit) -> ('c, 'c) pt -> unit
Perform a given action on every declaration in a given rel-context.
val fold_inside : ('a -> ('c, 't) Declaration.pt -> 'a) -> init:'a -> ('c, 't) pt -> 'a
Reduce all terms in a given rel-context to a single value. Innermost declarations are processed first.
val fold_outside : (('c, 't) Declaration.pt -> 'a -> 'a) -> ('c, 't) pt -> init:'a -> 'a
Reduce all terms in a given rel-context to a single value. Outermost declarations are processed first.
val to_vars : ('c, 't) pt -> Names.Id.Set.t
Return the set of all named variables bound in a given rel-context.
val to_tags : ('c, 't) pt -> bool list
Map a given rel-context to a list where each local assumption is mapped to true
and each local definition is mapped to false
. The resulting list is in reverse order compared to the order of declarations in the context.
Turn all LocalDef
into LocalAssum
, leave LocalAssum
unchanged.
chop_nhyps n Γ
returns Γ'',Γ'
such that Γ
=Γ'Γ''
, Γ''
has n
hypotheses (i.e. LocalAssum
), excluding local definitions (i.e. LocalDef
), and Γ''
, if n
non zero, starts with an hypothesis (i.e., Γ''
has the form x:A;Γ'''
, i.e., local definitions at the junction of the n
hypotheses are put in Γ'
rather than in Γ''
val instance : (int -> 'r) -> int -> ('c, 't) pt -> 'r array
instance mk n Γ
builds an instance args
such that Γ,Δ ⊢ args:Γ
with n = |Δ| and with the local definitions of Γ
skipped in args
where mk
is used to build the corresponding variables. Example: for x:T, y:=c, z:U
and n
=2, it gives mk 5, mk 3
.
val instance_list : (int -> 'r) -> int -> ('c, 't) pt -> 'r list
instance_list
is like instance
but returning a list.
val to_extended_vect : (int -> 'r) -> int -> ('c, 't) pt -> 'r array
val to_extended_list : (int -> 'r) -> int -> ('c, 't) pt -> 'r list