else
(fun () -> 0)
-let choice_of_uri uri =
- let term = CicUtil.term_of_uri uri in
- (uri, (fun _ _ _ -> term))
+let choice_of_uri suri =
+ let term = CicUtil.term_of_uri (UriManager.uri_of_string suri) in
+ (suri, (fun _ _ _ -> term))
let grammar = Grammar.gcreate cic_lexer
| [ IDENT "whd" ] -> `Whd
| [ IDENT "normalize" ] -> `Normalize ]
];
+ pattern_spec: [
+ [ "in";
+ hyp_paths =
+ LIST0
+ [ id = IDENT ;
+ path = OPT [SYMBOL ":" ; path = term -> path ] ->
+ (id,match path with Some p -> p | None -> CicAst.UserInput) ]
+ SEP SYMBOL ";";
+ goal_path = OPT [ SYMBOL <:unicode<vdash>>; term = term -> term ] ->
+ (hyp_paths, goal_path) ]
+ ];
+ direction: [
+ [ IDENT "left" -> `Left
+ | SYMBOL ">" -> `Left
+ | IDENT "right" -> `Right
+ | SYMBOL "<" -> `Right ]
+ ];
tactic: [
[ [ IDENT "absurd" ]; t = tactic_term ->
TacticAst.Absurd (loc, t)
where = IDENT ; SYMBOL <:unicode<def>> ; t = tactic_term ->
TacticAst.LetIn (loc, t, where)
| kind = reduction_kind;
- pat = OPT [
- "in"; pat = [ IDENT "goal" -> `Goal | IDENT "hyp" -> `Everywhere ] ->
- pat
- ];
- terms = LIST0 term SEP SYMBOL "," ->
- (match (pat, terms) with
- | None, [] -> TacticAst.Reduce (loc, kind, None)
- | None, terms -> TacticAst.Reduce (loc, kind, Some (terms, `Goal))
- | Some pat, [] -> fail loc "Missing term [list]"
- | Some pat, terms -> TacticAst.Reduce (loc, kind, Some (terms, pat)))
- | kind = reduction_kind; where = IDENT ; IDENT "at" ; pat = term ->
- TacticAst.ReduceAt (loc, kind, where, pat)
+ p = OPT [ pattern_spec ] ->
+ let p = match p with None -> [], None | Some p -> p in
+ TacticAst.Reduce (loc, kind, p)
+ | IDENT "generalize"; t = tactic_term; p = OPT [ pattern_spec ] ->
+ let p = match p with None -> [], None | Some p -> p in
+ TacticAst.Generalize (loc,t,p)
| [ IDENT "reflexivity" ] ->
TacticAst.Reflexivity loc
| [ IDENT "replace" ];
t1 = tactic_term; "with"; t2 = tactic_term ->
TacticAst.Replace (loc, t1, t2)
- | [ IDENT "rewrite" ; IDENT "left" ] ; t = term ->
- TacticAst.Rewrite (loc,`Left, t, None)
- | [ IDENT "rewrite" ; IDENT "right" ] ; t = term ->
- TacticAst.Rewrite (loc,`Right, t, None)
- (* TODO Replace_pattern *)
+ | IDENT "rewrite" ; d = direction; t = term ;
+ p = OPT [ pattern_spec ] ->
+ let p = match p with None -> [], None | Some p -> p in
+ TacticAst.Rewrite (loc, d, t, p)
| [ IDENT "right" ] -> TacticAst.Right loc
| [ IDENT "ring" ] -> TacticAst.Ring loc
| [ IDENT "split" ] -> TacticAst.Split loc
| [ IDENT "transitivity" ];
t = tactic_term ->
TacticAst.Transitivity (loc, t)
+ | [ IDENT "fwd" ]; name = IDENT ->
+ TacticAst.FwdSimpl (loc, name)
+ | [ IDENT "lapply" ]; t = term ->
+ TacticAst.LApply (loc, t, [])
]
];
tactical:
let ind_types = fst_ind_type :: tl_ind_types in
(params, ind_types)
] ];
-
+
+ record_spec: [ [
+ name = IDENT; params = LIST0 [ arg = arg -> arg ] ;
+ SYMBOL ":"; typ = term; SYMBOL <:unicode<def>>; PAREN "{" ;
+ fields = LIST0 [
+ name = IDENT ; SYMBOL ":" ; ty = term -> (name,ty)
+ ] SEP SYMBOL ";"; PAREN "}" ->
+ let params =
+ List.fold_right
+ (fun (names, typ) acc ->
+ (List.map (fun name -> (name, typ)) names) @ acc)
+ params []
+ in
+ (params,name,typ,fields)
+ ] ];
+
macro: [
[ [ IDENT "quit" ] -> TacticAst.Quit loc
(* | [ IDENT "abort" ] -> TacticAst.Abort loc *)
[ IDENT "set" ]; n = QSTRING; v = QSTRING ->
TacticAst.Set (loc, n, v)
| [ IDENT "qed" ] -> TacticAst.Qed loc
- | flavour = theorem_flavour; name = OPT IDENT; SYMBOL ":"; typ = term;
+ | flavour = theorem_flavour; name = IDENT; SYMBOL ":"; typ = term;
body = OPT [ SYMBOL <:unicode<def>> (* ≝ *); body = term -> body ] ->
- TacticAst.Theorem (loc, flavour, name, typ, body)
- | flavour = theorem_flavour; name = OPT IDENT;
+ TacticAst.Obj (loc,TacticAst.Theorem (flavour, name, typ, body))
+ | flavour = theorem_flavour; name = IDENT;
body = OPT [ SYMBOL <:unicode<def>> (* ≝ *); body = term -> body ] ->
- TacticAst.Theorem (loc, flavour, name, CicAst.Implicit, body)
+ TacticAst.Obj (loc,TacticAst.Theorem (flavour, name, CicAst.Implicit, body))
| "let"; ind_kind = [ "corec" -> `CoInductive | "rec"-> `Inductive ];
defs = let_defs ->
let name,ty =
| _ -> assert false
in
let body = CicAst.Ident (name,None) in
- TacticAst.Theorem(loc, `Definition, Some name, ty,
- Some (CicAst.LetRec (ind_kind, defs, body)))
+ TacticAst.Obj (loc,TacticAst.Theorem(`Definition, name, ty,
+ Some (CicAst.LetRec (ind_kind, defs, body))))
| [ IDENT "inductive" ]; spec = inductive_spec ->
let (params, ind_types) = spec in
- TacticAst.Inductive (loc, params, ind_types)
+ TacticAst.Obj (loc,TacticAst.Inductive (params, ind_types))
| [ IDENT "coinductive" ]; spec = inductive_spec ->
let (params, ind_types) = spec in
let ind_types = (* set inductive flags to false (coinductive) *)
List.map (fun (name, _, term, ctors) -> (name, false, term, ctors))
ind_types
in
- TacticAst.Inductive (loc, params, ind_types)
+ TacticAst.Obj (loc,TacticAst.Inductive (params, ind_types))
| [ IDENT "coercion" ] ; name = IDENT ->
TacticAst.Coercion (loc, CicAst.Ident (name,Some []))
| [ IDENT "coercion" ] ; name = URI ->
TacticAst.Coercion (loc, CicAst.Uri (name,Some []))
| [ IDENT "alias" ]; spec = alias_spec ->
TacticAst.Alias (loc, spec)
+ | [ IDENT "record" ]; (params,name,ty,fields) = record_spec ->
+ TacticAst.Obj (loc,TacticAst.Record (params,name,ty,fields))
]];
executable: [
]
];
statements: [
- [ l = LIST0 [ statement ] -> l
+ [ l = LIST0 statement ; EOI -> l
]
];
END
alias: [ (* return a pair <domain_item, codomain_item> from an alias *)
[ IDENT "alias";
choice =
- [ IDENT "id"; id = IDENT; SYMBOL "="; uri = URI ->
- (Id id, choice_of_uri uri)
+ [ IDENT "id"; id = IDENT; SYMBOL "="; suri = URI ->
+ (Id id, choice_of_uri suri)
| IDENT "symbol"; symbol = QSTRING;
PAREN "("; IDENT "instance"; instance = NUM; PAREN ")";
SYMBOL "="; dsc = QSTRING ->
projects / helm.git / blobdiff