1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
|
(***********************************************************************)
(* v * The Coq Proof Assistant / The Coq Development Team *)
(* <O___,, * INRIA-Rocquencourt & LRI-CNRS-Orsay *)
(* \VV/ *************************************************************)
(* // * This file is distributed under the terms of the *)
(* * GNU Lesser General Public License Version 2.1 *)
(***********************************************************************)
(* $Id$ *)
(*i*)
open Util
open Names
open Sign
open Term
open Libnames
open Nametab
(*i*)
(* Untyped intermediate terms, after ASTs and before constr. *)
type loc = int * int
(* locs here refers to the ident's location, not whole pat *)
(* the last argument of PatCstr is a possible alias ident for the pattern *)
type cases_pattern =
| PatVar of loc * name
| PatCstr of loc * constructor * cases_pattern list * name
type rawsort = RProp of Term.contents | RType of Univ.universe option
type fix_kind = RFix of (int array * int) | RCoFix of int
type binder_kind = BProd | BLambda | BLetIn
type quantified_hypothesis = AnonHyp of int | NamedHyp of identifier
type 'a explicit_substitution = (quantified_hypothesis * 'a) list
type 'a substitution =
| ImplicitBindings of 'a list
| ExplicitBindings of 'a explicit_substitution
| NoBindings
type 'a with_bindings = 'a * 'a substitution
type hole_kind =
| ImplicitArg of global_reference * int
| AbstractionType of name
| QuestionMark
| CasesType
| InternalHole
type 'ctxt reference =
| RConst of constant * 'ctxt
| RInd of inductive * 'ctxt
| RConstruct of constructor * 'ctxt
| RVar of identifier
| REVar of int * 'ctxt
type rawconstr =
| RRef of loc * global_reference
| RVar of loc * identifier
| REvar of loc * existential_key
| RMeta of loc * int
| RApp of loc * rawconstr * rawconstr list
| RLambda of loc * name * rawconstr * rawconstr
| RProd of loc * name * rawconstr * rawconstr
| RLetIn of loc * name * rawconstr * rawconstr
| RCases of loc * Term.case_style * rawconstr option * rawconstr list *
(loc * identifier list * cases_pattern list * rawconstr) list
| ROldCase of loc * bool * rawconstr option * rawconstr *
rawconstr array
| RRec of loc * fix_kind * identifier array *
rawconstr array * rawconstr array
| RSort of loc * rawsort
| RHole of (loc * hole_kind)
| RCast of loc * rawconstr * rawconstr
| RDynamic of loc * Dyn.t
(*i - if PRec (_, names, arities, bodies) is in env then arities are
typed in env too and bodies are typed in env enriched by the
arities incrementally lifted
[On pourrait plutot mettre les arités aves le type qu'elles auront
dans le contexte servant à typer les body ???]
- boolean in POldCase means it is recursive
i*)
let rec subst_pat subst pat =
match pat with
| PatVar _ -> pat
| PatCstr (loc,((kn,i),j),cpl,n) ->
let kn' = subst_kn subst kn
and cpl' = list_smartmap (subst_pat subst) cpl in
if kn' == kn && cpl' == cpl then pat else
PatCstr (loc,((kn',i),j),cpl',n)
let rec subst_raw subst raw =
match raw with
| RRef (loc,ref) ->
let ref' = subst_global subst ref in
if ref' == ref then raw else
RRef (loc,ref')
| RVar _ -> raw
| REvar _ -> raw
| RMeta _ -> raw
| RApp (loc,r,rl) ->
let r' = subst_raw subst r
and rl' = list_smartmap (subst_raw subst) rl in
if r' == r && rl' == rl then raw else
RApp(loc,r',rl')
| RLambda (loc,n,r1,r2) ->
let r1' = subst_raw subst r1 and r2' = subst_raw subst r2 in
if r1' == r1 && r2' == r2 then raw else
RLambda (loc,n,r1',r2')
| RProd (loc,n,r1,r2) ->
let r1' = subst_raw subst r1 and r2' = subst_raw subst r2 in
if r1' == r1 && r2' == r2 then raw else
RProd (loc,n,r1',r2')
| RLetIn (loc,n,r1,r2) ->
let r1' = subst_raw subst r1 and r2' = subst_raw subst r2 in
if r1' == r1 && r2' == r2 then raw else
RLetIn (loc,n,r1',r2')
| RCases (loc,cs,ro,rl,branches) ->
let ro' = option_smartmap (subst_raw subst) ro
and rl' = list_smartmap (subst_raw subst) rl
and branches' = list_smartmap
(fun (loc,idl,cpl,r as branch) ->
let cpl' = list_smartmap (subst_pat subst) cpl
and r' = subst_raw subst r in
if cpl' == cpl && r' == r then branch else
(loc,idl,cpl',r'))
branches
in
if ro' == ro && rl' == rl && branches' == branches then raw else
RCases (loc,cs,ro',rl',branches')
| ROldCase (loc,b,ro,r,ra) ->
let ro' = option_smartmap (subst_raw subst) ro
and r' = subst_raw subst r
and ra' = array_smartmap (subst_raw subst) ra in
if ro' == ro && r' == r && ra' == ra then raw else
ROldCase (loc,b,ro',r',ra')
| RRec (loc,fix,ida,ra1,ra2) ->
let ra1' = array_smartmap (subst_raw subst) ra1
and ra2' = array_smartmap (subst_raw subst) ra2 in
if ra1' == ra1 && ra2' == ra2 then raw else
RRec (loc,fix,ida,ra1',ra2')
| RSort _ -> raw
| RHole (loc,ImplicitArg (ref,i)) ->
let ref' = subst_global subst ref in
if ref' == ref then raw else
RHole (loc,ImplicitArg (ref',i))
| RHole (loc,
(AbstractionType _ | QuestionMark | CasesType | InternalHole)) ->
raw
| RCast (loc,r1,r2) ->
let r1' = subst_raw subst r1 and r2' = subst_raw subst r2 in
if r1' == r1 && r2' == r2 then raw else
RCast (loc,r1',r2')
| RDynamic _ -> raw
let dummy_loc = (0,0)
let loc_of_rawconstr = function
| RRef (loc,_) -> loc
| RVar (loc,_) -> loc
| REvar (loc,_) -> loc
| RMeta (loc,_) -> loc
| RApp (loc,_,_) -> loc
| RLambda (loc,_,_,_) -> loc
| RProd (loc,_,_,_) -> loc
| RLetIn (loc,_,_,_) -> loc
| RCases (loc,_,_,_,_) -> loc
| ROldCase (loc,_,_,_,_) -> loc
| RRec (loc,_,_,_,_) -> loc
| RSort (loc,_) -> loc
| RHole (loc,_) -> loc
| RCast (loc,_,_) -> loc
| RDynamic (loc,_) -> loc
let set_loc_of_rawconstr loc = function
| RRef (_,a) -> RRef (loc,a)
| RVar (_,a) -> RVar (loc,a)
| REvar (_,a) -> REvar (loc,a)
| RMeta (_,a) -> RMeta (loc,a)
| RApp (_,a,b) -> RApp (loc,a,b)
| RLambda (_,a,b,c) -> RLambda (loc,a,b,c)
| RProd (_,a,b,c) -> RProd (loc,a,b,c)
| RLetIn (_,a,b,c) -> RLetIn (loc,a,b,c)
| RCases (_,a,b,c,d) -> RCases (loc,a,b,c,d)
| ROldCase (_,a,b,c,d) -> ROldCase (loc,a,b,c,d)
| RRec (_,a,b,c,d) -> RRec (loc,a,b,c,d)
| RSort (_,a) -> RSort (loc,a)
| RHole (_,a) -> RHole (loc,a)
| RCast (_,a,b) -> RCast (loc,a,b)
| RDynamic (_,d) -> RDynamic (loc,d)
let join_loc (deb1,_) (_,fin2) = (deb1,fin2)
type 'a raw_red_flag = {
rBeta : bool;
rIota : bool;
rZeta : bool;
rDelta : bool; (* true = delta all but rConst; false = delta only on rConst*)
rConst : 'a list
}
type ('a,'b) red_expr_gen =
| Red of bool
| Hnf
| Simpl
| Cbv of 'b raw_red_flag
| Lazy of 'b raw_red_flag
| Unfold of (int list * 'b) list
| Fold of 'a list
| Pattern of (int list * 'a) list
| ExtraRedExpr of string * 'a
type 'a or_metanum = AN of loc * 'a | MetaNum of loc * int
type 'a may_eval =
| ConstrTerm of 'a
| ConstrEval of ('a, qualid or_metanum) red_expr_gen * 'a
| ConstrContext of (loc * identifier) * 'a
| ConstrTypeOf of 'a
|
