V_______________________________________________________________ *)
module U = NUri
-module N = Level
+module N = Layer
type uri = U.uri
type name = id * bool (* token, real? *)
-type names = name list
+type arity = int * int (* sort, degree *)
type meta = Main (* main object *)
| InProp (* inhabitant of a proposition *)
| Progress (* uncompleted object *)
| Private (* private global definition *)
-type attr = Name of name (* name *)
- | Apix of int (* additional position index *)
- | Mark of int (* node marker *)
- | Meta of meta list (* metaliguistic classification *)
- | Info of (string * string) (* metaliguistic annotation: language (defaults to "en-US"), text *)
+type node_attrs = {
+ n_apix: int; (* additional position index *)
+}
-type attrs = attr list (* attributes *)
+type appl_attrs = {
+ a_rest: bool; (* restricted application? *)
+ a_main: arity; (* main arity *)
+ a_side: arity; (* side arity *)
+}
-type 'term bind = Abst of N.level * 'term (* declaration: level, domain *)
- | Abbr of 'term (* definition: body *)
- | Void (* exclusion *)
+type bind_attrs = {
+ b_name: name option; (* name *)
+ b_main: arity; (* main arity *)
+ b_side: arity; (* side arity *)
+}
-type 'term entity = attrs * uri * 'term bind (* attrs, name, binder *)
+type root_attrs = {
+ r_meta: meta list; (* metaliguistic classification *)
+ r_info: (string * string) option; (* metaliguistic annotation: language (defaults to "en-US"), text *)
+}
+
+type env_attrs = {
+ e_side: arity; (* arity *)
+}
+
+
+type 'term bind = Abst of env_attrs * 'term (* declaration: attrs, domain *)
+ | Abbr of env_attrs * 'term (* definition: attrs, body *)
+ | Void (* exclusion *)
+
+type 'term entity = root_attrs * node_attrs * uri * 'term bind (* attrs, uri, binder *)
(* helpers ******************************************************************)
-let common f (a, u, _) = f a u
-
-let rec name err f = function
- | Name (n, r) :: _ -> f n r
- | _ :: tl -> name err f tl
- | [] -> err ()
-
-let names f map l a =
- let rec aux f i a = function
- | [] -> f a
- | Name (n, r) :: tl -> aux (map f i n r) false a tl
- | _ :: tl -> aux f i a tl
- in
- aux f true a l
-
-let rec get_name err f j = function
- | [] -> err ()
- | Name (n, r) :: _ when j = 0 -> f n r
- | Name _ :: tl -> get_name err f (pred j) tl
- | _ :: tl -> get_name err f j tl
-
-let rec get_names f = function
- | [] -> f [] []
- | Name _ as n :: tl ->
- let f a ns = f a (n :: ns) in get_names f tl
- | e :: tl ->
- let f a = f (e :: a) in get_names f tl
-
-let count_names a =
- let rec aux k = function
- | [] -> k
- | Name _ :: tl -> aux (succ k) tl
- | _ :: tl -> aux k tl
- in
- aux 0 a
-
-let rec apix err f = function
- | Apix i :: _ -> f i
- | _ :: tl -> apix err f tl
- | [] -> err ()
-
-let rec mark err f = function
- | Mark i :: _ -> f i
- | _ :: tl -> mark err f tl
- | [] -> err ()
-
-let rec meta err f = function
- | Meta ms :: _ -> f ms
- | _ :: tl -> meta err f tl
- | [] -> err ()
-
-let rec info err f = function
- | Info (lg, tx) :: _ -> f lg tx
- | _ :: tl -> info err f tl
- | [] -> err ()
-
-let resolve err f name a =
- let rec aux i = function
- | Name (n, true) :: _ when n = name -> f i
- | _ :: tl -> aux (succ i) tl
- | [] -> err i
- in
- aux 0 a
-
-let rec rev_append_names ns = function
- | [] -> ns
- | Name n :: tl -> rev_append_names (n :: ns) tl
- | _ :: tl -> rev_append_names ns tl
+let node_attrs ?(apix=0) () = {
+ n_apix = apix;
+}
+
+let appl_attrs ?(main=(0,0)) ?(side=(0,0)) rest = {
+ a_rest = rest; a_main = main; a_side = side;
+}
+
+let bind_attrs ?name ?(main=(0,0)) ?(side=(0,0)) () = {
+ b_name = name; b_main = main; b_side = side;
+}
+
+let root_attrs ?(meta=[]) ?info () = {
+ r_meta = meta; r_info = info;
+}
+
+let env_attrs ?(side=(0,0)) () = {
+ e_side = side;
+}
+
+let empty_node = node_attrs ()
+
+let empty_bind = bind_attrs ()
+
+let empty_root = root_attrs ()
+
+let empty_env = env_attrs ()
+
+let abst a t = Abst (a, t)
+
+let abbr a t = Abbr (a, t)
+
+let common f (ra, na, u, _) = f ra na u
+
+let succ (sort, degr) = sort, succ degr
+
+let compose av yt = {av with b_main = yt}
+
+let rec name err f a = match a.b_name with
+ | Some (n, r) -> f n r
+ | None -> err ()
+
+let rec info err f a = match a.r_info with
+ | Some (lg, tx) -> f lg tx
+ | None -> err ()
let xlate f xlate_term = function
- | a, uri, Abst (n, t) ->
- let f t = f (a, uri, Abst (n, t)) in xlate_term f t
- | a, uri, Abbr t ->
- let f t = f (a, uri, Abbr t) in xlate_term f t
- | _, _, Void ->
+ | ra, na, uri, Abst (a, t) ->
+ let f t = f (ra, na, uri, abst a t) in xlate_term f t
+ | ra, na, uri, Abbr (a, t) ->
+ let f t = f (ra, na, uri, abbr a t) in xlate_term f t
+ | _, _, _, Void ->
assert false
projects / helm.git / blobdiff