viewcvs.cgi/typing/typed.ml

(* Typed abstract syntax *) 

(*  Some sub-expression may have to be type-checked several times.
    We first build the ``skeleton'' of the typed ast
    (basically the parsed ast with types and patterns replaced with there
    internal representation), then type check it.

    The exp_typ and br_typ fields are updated to capture all the possible
    values than can result from the expression or flow to the branch
*)

open Location

type tpat = Patterns.node
type ttyp = Types.node

type texpr  = { exp_loc : loc; 
                mutable exp_typ : Types.descr; 
                exp_descr : texpr';
              }
and  texpr' = 
  (* CDuce is a Lambda-calculus ... *)
  | Var of string
  | Apply of texpr * texpr
  | Abstraction of abstr
      
  (* Data constructors *)
  | Cst of Types.const
  | Pair of texpr * texpr
  | RecordLitt of (Types.label * texpr) list
      
  (* Data destructors *)
  | UnaryOp of Op.unary * texpr
  | BinaryOp of Op.binary * texpr * texpr
  | Match of texpr * branches
  | Map of texpr * branches

and abstr = { 
  fun_name : string option; 
  fun_iface : (Types.descr * Types.descr) list;
  fun_body : branches;
  fun_typ  : Types.descr;
  fun_fv   : string list;
}

and branches = { 
  mutable br_typ : Types.descr;
  br_branches: branch list
}
and branch = { 
  mutable br_used : bool; 
  br_pat : tpat; 
  br_body :  texpr 
}

1	(* Typed abstract syntax *)
2
3	(* Some sub-expression may have to be type-checked several times.
4	We first build the ``skeleton'' of the typed ast
5	(basically the parsed ast with types and patterns replaced with there
6	internal representation), then type check it.
7
8	The exp_typ and br_typ fields are updated to capture all the possible
9	values than can result from the expression or flow to the branch
10	*)
11
12	open Location
13
14	type tpat = Patterns.node
15	type ttyp = Types.node
16
17	type texpr = { exp_loc : loc;
18	mutable exp_typ : Types.descr;
19	exp_descr : texpr';
20	}
21	and texpr' =
22	(* CDuce is a Lambda-calculus ... *)
23	\| Var of string
24	\| Apply of texpr * texpr
25	\| Abstraction of abstr
26
27	(* Data constructors *)
28	\| Cst of Types.const
29	\| Pair of texpr * texpr
30	\| RecordLitt of (Types.label * texpr) list
31
32	(* Data destructors *)
33	\| UnaryOp of Op.unary * texpr
34	\| BinaryOp of Op.binary * texpr * texpr
35	\| Match of texpr * branches
36	\| Map of texpr * branches
37
38	and abstr = {
39	fun_name : string option;
40	fun_iface : (Types.descr * Types.descr) list;
41	fun_body : branches;
42	fun_typ : Types.descr;
43	fun_fv : string list;
44	}
45
46	and branches = {
47	mutable br_typ : Types.descr;
48	br_branches: branch list
49	}
50	and branch = {
51	mutable br_used : bool;
52	br_pat : tpat;
53	br_body : texpr
54	}
55