else
`MutualDefinition
in
- (loc, N.Theorem(flavour, name, ty, Some (N.LetRec (ind_kind, defs, body))))
+ (loc, N.Theorem(flavour, name, ty, Some (N.LetRec (ind_kind, defs, body)), `Regular))
let nmk_rec_corec ind_kind defs loc =
let loc,t = mk_rec_corec ind_kind defs loc in
G.NCases (loc, what, where)
| IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term ->
G.NChange (loc, what, with_what)
- | SYMBOL "@"; num = OPT NUMBER ->
+ | SYMBOL "@"; num = OPT NUMBER; l = LIST0 tactic_term ->
G.NConstructor (loc,
- match num with None -> None | Some x -> Some (int_of_string x))
+ (match num with None -> None | Some x -> Some (int_of_string x)),l)
+ | IDENT "ncut"; t = tactic_term -> G.NCut (loc, t)
| IDENT "nelim"; what = tactic_term ; where = pattern_spec ->
G.NElim (loc, what, where)
| IDENT "ngeneralize"; p=pattern_spec ->
G.NGeneralize (loc, p)
+ | IDENT "nlapply"; t = tactic_term -> G.NLApply (loc, t)
| IDENT "nletin"; name = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term;
where = pattern_spec ->
G.NLetIn (loc,where,t,name)
nmacro: [
[ [ IDENT "ncheck" ]; t = term -> G.NCheck (loc,t)
+ | [ IDENT "screenshot"]; fname = QSTRING -> G.Screenshot (loc, fname)
]
];
IDENT "nqed" -> G.NQed loc
| nflavour = ntheorem_flavour; name = IDENT; SYMBOL ":"; typ = term;
body = OPT [ SYMBOL <:unicode<def>> (* ≝ *); body = term -> body ] ->
- G.NObj (loc, N.Theorem (nflavour, name, typ, body))
+ G.NObj (loc, N.Theorem (nflavour, name, typ, body,`Regular))
| nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode<def>> (* ≝ *);
body = term ->
- G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body))
+ G.NObj (loc, N.Theorem (nflavour, name, N.Implicit `JustOne, Some body,`Regular))
| IDENT "naxiom"; name = IDENT; SYMBOL ":"; typ = term ->
- G.NObj (loc, N.Theorem (`Axiom, name, typ, None))
+ G.NObj (loc, N.Theorem (`Axiom, name, typ, None, `Regular))
+ | IDENT "ninverter"; name = IDENT; IDENT "for" ; indty = tactic_term ;
+ paramspec = OPT inverter_param_list ;
+ outsort = OPT [ SYMBOL ":" ; outsort = term -> outsort ] ->
+ G.NInverter (loc,name,indty,paramspec,outsort)
| NLETCOREC ; defs = let_defs ->
nmk_rec_corec `CoInductive defs loc
| NLETREC ; defs = let_defs ->
in
G.NObj (loc, N.Inductive (params, ind_types))
| IDENT "universe"; IDENT "constraint"; u1 = tactic_term;
- strict = [ SYMBOL <:unicode<lt>> -> true
- | SYMBOL <:unicode<leq>> -> false ];
- u2 = tactic_term ->
- let u1 =
- match u1 with
+ SYMBOL <:unicode<lt>> ; u2 = tactic_term ->
+ let urify = function
| CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) ->
NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ")
- | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NCProp i)) ->
- NUri.uri_of_string ("cic:/matita/pts/CProp"^i^".univ")
- | _ -> raise (Failure "only a sort can be constrained")
+ | _ -> raise (Failure "only a Type[…] sort can be constrained")
in
- let u2 =
- match u2 with
- | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NType i)) ->
- NUri.uri_of_string ("cic:/matita/pts/Type"^i^".univ")
- | CicNotationPt.AttributedTerm (_, CicNotationPt.Sort (`NCProp i)) ->
- NUri.uri_of_string ("cic:/matita/pts/CProp"^i^".univ")
- | _ -> raise (Failure "only a sort can be constrained")
- in
- G.NUnivConstraint (loc, strict,u1,u2)
+ let u1 = urify u1 in
+ let u2 = urify u2 in
+ G.NUnivConstraint (loc,u1,u2)
| IDENT "unification"; IDENT "hint"; n = int; t = tactic_term ->
G.UnificationHint (loc, t, n)
| IDENT "ncoercion"; name = IDENT; SYMBOL ":"; ty = term;
typ = term; SYMBOL <:unicode<def>> ; newname = IDENT ->
G.Obj (loc,
N.Theorem
- (`Variant,name,typ,Some (N.Ident (newname, None))))
+ (`Variant,name,typ,Some (N.Ident (newname, None)), `Regular))
| flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term;
body = OPT [ SYMBOL <:unicode<def>> (* ≝ *); body = term -> body ] ->
- G.Obj (loc, N.Theorem (flavour, name, typ, body))
+ G.Obj (loc, N.Theorem (flavour, name, typ, body,`Regular))
| flavour = theorem_flavour; name = IDENT; SYMBOL <:unicode<def>> (* ≝ *);
body = term ->
G.Obj (loc,
- N.Theorem (flavour, name, N.Implicit `JustOne, Some body))
+ N.Theorem (flavour, name, N.Implicit `JustOne, Some body,`Regular))
| IDENT "axiom"; name = IDENT; SYMBOL ":"; typ = term ->
- G.Obj (loc, N.Theorem (`Axiom, name, typ, None))
+ G.Obj (loc, N.Theorem (`Axiom, name, typ, None, `Regular))
| LETCOREC ; defs = let_defs ->
mk_rec_corec `CoInductive defs loc
| LETREC ; defs = let_defs ->