`MutualDefinition to rememer this. *)
let name,ty =
match defs with
- | (params,(N.Ident (name, None), Some ty),_,_) :: _ ->
+ | (params,(N.Ident (name, None), ty),_,_) :: _ ->
+ let ty = match ty with Some ty -> ty | None -> N.Implicit in
let ty =
List.fold_right
(fun var ty -> N.Binder (`Pi,var,ty)
) params ty
in
name,ty
- | (_,(N.Ident (name, None), None),_,_) :: _ ->
- name, N.Implicit
| _ -> assert false
in
let body = N.Ident (name,None) in
constructor: [ [ name = IDENT; SYMBOL ":"; typ = term -> (name, typ) ] ];
tactic_term: [ [ t = term LEVEL "90" -> t ] ];
new_name: [
- [ id = IDENT -> Some id
- | SYMBOL "_" -> None ]
+ [ SYMBOL "_" -> None
+ | id = IDENT -> Some id ]
];
ident_list0: [ [ LPAREN; idents = LIST0 new_name; RPAREN -> idents ] ];
tactic_term_list1: [
| IDENT "unfold"; t = OPT tactic_term -> `Unfold t
| IDENT "whd" -> `Whd ]
];
+ nreduction_kind: [
+ [ IDENT "nnormalize" ; delta = OPT [ IDENT "nodelta" -> () ] ->
+ let delta = match delta with None -> true | _ -> false in
+ `Normalize delta
+ (*| IDENT "unfold"; t = OPT tactic_term -> `Unfold t*)
+ | IDENT "nwhd" ; delta = OPT [ IDENT "nodelta" -> () ] ->
+ let delta = match delta with None -> true | _ -> false in
+ `Whd delta]
+ ];
sequent_pattern_spec: [
[ hyp_paths =
LIST0
SYMBOL <:unicode<vdash>>;
concl = tactic_term -> (List.rev hyps,concl) ] ->
G.NAssert (loc, seqs)
+ | IDENT "nauto"; params = auto_params -> G.NAuto (loc, params)
| IDENT "ncases"; what = tactic_term ; where = pattern_spec ->
G.NCases (loc, what, where)
| IDENT "nchange"; what = pattern_spec; "with"; with_what = tactic_term ->
| IDENT "nletin"; name = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term;
where = pattern_spec ->
G.NLetIn (loc,where,t,name)
+ | kind = nreduction_kind; p = pattern_spec ->
+ G.NReduce (loc, kind, p)
| IDENT "nrewrite"; dir = direction; what = tactic_term ; where = pattern_spec ->
G.NRewrite (loc, dir, what, where)
- | IDENT "nwhd"; delta = OPT [ IDENT "nodelta" -> () ];
- where = pattern_spec ->
- let delta = match delta with None -> true | _ -> false in
- G.NEval (loc, where, `Whd delta)
| SYMBOL "#"; n=IDENT -> G.NIntro (loc,n)
| SYMBOL "#"; SYMBOL "_" -> G.NIntro (loc,"_")
| SYMBOL "*" -> G.NCase1 (loc,"_")
(match tl with Some l -> l | None -> []),
params
]
+];
+ inline_params:[
+ [ params = LIST0
+ [ IDENT "prefix"; SYMBOL "="; prefix = QSTRING -> G.IPPrefix prefix
+ | flavour = inline_flavour -> G.IPAs flavour
+ | IDENT "procedural" -> G.IPProcedural
+ | IDENT "nodefaults" -> G.IPNoDefaults
+ | IDENT "depth"; SYMBOL "="; depth = int -> G.IPDepth depth
+ | IDENT "level"; SYMBOL "="; level = int -> G.IPLevel level
+ | IDENT "comments" -> G.IPComments
+ | IDENT "coercions" -> G.IPCoercions
+ | IDENT "debug"; SYMBOL "="; debug = int -> G.IPDebug debug
+ ] -> params
+ ]
];
by_continuation: [
[ WEPROVED; ty = tactic_term ; LPAREN ; id = IDENT ; RPAREN ; t1 = OPT [IDENT "that" ; IDENT "is" ; IDENT "equivalent" ; "to" ; t2 = tactic_term -> t2] -> BYC_weproved (ty,Some id,t1)
inline_flavour: [
[ attr = theorem_flavour -> attr
| [ IDENT "axiom" ] -> `Axiom
- | [ IDENT "mutual" ] -> `MutualDefinition
+ | [ IDENT "variant" ] -> `Variant
]
];
inductive_spec: [ [
G.Check (loc, t)
| [ IDENT "eval" ]; kind = reduction_kind; "on"; t = tactic_term ->
G.Eval (loc, kind, t)
- | [ IDENT "inline"];
- style = OPT [ IDENT "procedural"; depth = OPT int -> depth ];
- suri = QSTRING; prefix = OPT QSTRING;
- flavour = OPT [ "as"; attr = inline_flavour -> attr ] ->
- let style = match style with
- | None -> G.Declarative
- | Some depth -> G.Procedural depth
- in
- let prefix = match prefix with None -> "" | Some prefix -> prefix in
- G.Inline (loc,style,suri,prefix, flavour)
+ | IDENT "inline"; suri = QSTRING; params = inline_params ->
+ G.Inline (loc, suri, params)
| [ IDENT "hint" ]; rew = OPT (IDENT "rewrite") ->
if rew = None then G.Hint (loc, false) else G.Hint (loc,true)
| IDENT "auto"; params = auto_params ->
in
L.Number_alias (instance, dsc)
]
- ];
+ ];
argument: [
[ l = LIST0 [ SYMBOL <:unicode<eta>> (* η *); SYMBOL "." -> () ];
id = IDENT ->
];
level3_term: [
[ u = URI -> N.UriPattern (UriManager.uri_of_string u)
+ | r = NREF -> N.NRefPattern (NReference.reference_of_string r)
+ | IMPLICIT -> N.ImplicitPattern
| id = IDENT -> N.VarPattern id
- | SYMBOL "_" -> N.ImplicitPattern
| LPAREN; terms = LIST1 SELF; RPAREN ->
(match terms with
| [] -> assert false
include_command: [ [
IDENT "include" ; path = QSTRING ->
- loc,path,L.WithPreferences
+ loc,path,true,L.WithPreferences
+ | IDENT "include" ; IDENT "source" ; path = QSTRING ->
+ loc,path,false,L.WithPreferences
| IDENT "include'" ; path = QSTRING ->
- loc,path,L.WithoutPreferences
+ loc,path,true,L.WithoutPreferences
]];
grafite_command: [ [
| 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))
+ | nflavour = ntheorem_flavour; name = IDENT; SYMBOL <:unicode<def>> (* ≝ *);
+ body = term ->
+ G.NObj (loc, N.Theorem (nflavour, name, N.Implicit, Some body))
| 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))
ind_types
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
+ | 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
+ 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)
| IDENT "coercion" ;
t = [ u = URI -> N.Uri (u,None) | t = tactic_term ; OPT "with" -> t ] ;
arity = OPT int ; saturations = OPT int;
indty = tactic_term; paramspec = inverter_param_list ->
G.Inverter
(loc, name, indty, paramspec)
- | IDENT "record" ; (params,name,ty,fields) = record_spec ->
+ | IDENT "record" ; (params,name,ty,fields) = record_spec ->
G.Obj (loc, N.Record (params,name,ty,fields))
+ | IDENT "nrecord" ; (params,name,ty,fields) = record_spec ->
+ G.NObj (loc, N.Record (params,name,ty,fields))
| IDENT "default" ; what = QSTRING ; uris = LIST1 URI ->
let uris = List.map UriManager.uri_of_string uris in
G.Default (loc,what,uris)
G.NTactic (loc, G.NId loc, punct)
| tac = non_punctuation_tactical; punct = punctuation_tactical ->
G.NonPunctuationTactical (loc, tac, punct)
+ | SYMBOL "#" ; SYMBOL "#" ; tac = non_punctuation_tactical; punct = punctuation_tactical ->
+ G.NNonPunctuationTactical (loc, tac, punct)
| mac = macro; SYMBOL "." -> G.Macro (loc, mac)
]
];
let stm = G.Comment (loc, com) in
!grafite_callback status stm;
status, LSome stm
- | (iloc,fname,mode) = include_command ; SYMBOL "." ->
+ | (iloc,fname,normal,mode) = include_command ; SYMBOL "." ->
fun ?(never_include=false) ~include_paths status ->
let stm =
- G.Executable (loc, G.Command (loc, G.Include (iloc, fname)))
+ G.Executable (loc, G.Command (loc, G.Include (iloc, normal, fname)))
in
!grafite_callback status stm;
let _root, buri, fullpath, _rrelpath =
Librarian.baseuri_of_script ~include_paths fname
in
- let stm =
- G.Executable (loc, G.Command (loc, G.Include (iloc, buri)))
- in
let status =
if never_include then raise (NoInclusionPerformed fullpath)
else LE.eval_command status (L.Include (iloc,buri,mode,fullpath))
in
+ let stm =
+ G.Executable (loc, G.Command (loc, G.Include (iloc, normal, buri)))
+ in
status, LSome stm
| scom = lexicon_command ; SYMBOL "." ->
fun ?(never_include=false) ~include_paths status ->
projects / helm.git / blobdiff