Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Diff of /sml/branches/primop-branch-2/src/compiler/FLINT/kernel/ltydef.sig
ViewVC logotype

Diff of /sml/branches/primop-branch-2/src/compiler/FLINT/kernel/ltydef.sig

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 24, Thu Mar 12 00:49:58 1998 UTC revision 45, Sun Mar 22 20:11:09 1998 UTC
# Line 13  Line 13 
13  sig  sig
14    
15  (** basic entities *)  (** basic entities *)
 type tkind = LtyKernel.tkind  
16  type index = DebIndex.index  type index = DebIndex.index
17  type depth = DebIndex.depth  type depth = DebIndex.depth
18  type primtyc = PrimTyc.primtyc  type primtyc = PrimTyc.primtyc
19  type tvar = LtyKernel.tvar  type tvar = LtyKernel.tvar
20    
21    type fflag = LtyKernel.fflag
22    type rflag = LtyKernel.rflag
23    
24    type tkind = LtyKernel.tkind
25  type tyc = LtyKernel.tyc  type tyc = LtyKernel.tyc
26  type lty = LtyKernel.lty  type lty = LtyKernel.lty
 type rawflag = bool * bool  (* should be equivalent to LtyKernel.rawflag *)  
27    
28  (*  (*
29   * FLINT tkind is roughly equivalent to the following ML datatype   * FLINT tkind is roughly equivalent to the following ML datatype
# Line 40  Line 43 
43  val tkc_mono   : tkind  val tkc_mono   : tkind
44  val tkc_box    : tkind  val tkc_box    : tkind
45  val tkc_seq    : tkind list -> tkind  val tkc_seq    : tkind list -> tkind
46  val tkc_fun    : tkind * tkind -> tkind  val tkc_fun    : tkind list * tkind -> tkind
47    
48  (** tkind deconstructors *)  (** tkind deconstructors *)
49  val tkd_mono   : tkind -> unit  val tkd_mono   : tkind -> unit
50  val tkd_box    : tkind -> unit  val tkd_box    : tkind -> unit
51  val tkd_seq    : tkind -> tkind list  val tkd_seq    : tkind -> tkind list
52  val tkd_fun    : tkind -> tkind * tkind  val tkd_fun    : tkind -> tkind list * tkind
53    
54  (** tkind predicates *)  (** tkind predicates *)
55  val tkp_mono   : tkind -> bool  val tkp_mono   : tkind -> bool
# Line 58  Line 61 
61  val tkw_mono   : tkind * (unit -> 'a) * (tkind -> 'a) -> 'a  val tkw_mono   : tkind * (unit -> 'a) * (tkind -> 'a) -> 'a
62  val tkw_box    : tkind * (unit -> 'a) * (tkind -> 'a) -> 'a  val tkw_box    : tkind * (unit -> 'a) * (tkind -> 'a) -> 'a
63  val tkw_seq    : tkind * (tkind list -> 'a) * (tkind -> 'a) -> 'a  val tkw_seq    : tkind * (tkind list -> 'a) * (tkind -> 'a) -> 'a
64  val tkw_fun    : tkind * (tkind * tkind -> 'a) * (tkind -> 'a) -> 'a  val tkw_fun    : tkind * (tkind list * tkind -> 'a) * (tkind -> 'a) -> 'a
65    
66    
67    (*
68     * FLINT fflag and rflag are used to classify different kinds of monomorphic
69     * functions and records. As of now, they are roughly equivalent to:
70     *
71     *    datatype fflag
72     *      = FF_VAR of bool * bool
73     *      | FF_FIXED
74     *
75     *    datatype rflag = RF_TMP
76     *
77     * We treat both as abstract types so pattern matching no longer applies.
78     * NOTE: FF_VAR flags are used by FLINTs before we perform representation
79     * analysis while FF_FIXED is used by FLINTs after we perform representation
80     * analysis.
81     *)
82    
83    (** fflag and rflag constructors *)
84    val ffc_var    : bool * bool -> fflag
85    val ffc_fixed  : fflag
86    val rfc_tmp    : rflag
87    
88    (** fflag and rflag deconstructors *)
89    val ffd_var    : fflag -> bool * bool
90    val ffd_fixed  : fflag -> unit
91    val rfd_tmp    : rflag -> unit
92    
93    (** fflag and rflag predicates *)
94    val ffp_var    : fflag -> bool
95    val ffp_fixed  : fflag -> bool
96    val rfp_tmp    : rflag -> bool
97    
98    (** fflag and rflag one-arm switch *)
99    val ffw_var    : fflag * (bool * bool -> 'a) * (fflag -> 'a) -> 'a
100    val ffw_fixed  : fflag * (unit -> 'a) * (fflag -> 'a) -> 'a
101    val rfw_tmp    : rflag * (unit -> 'a) * (rflag -> 'a) -> 'a
102    
103    
104  (*  (*
# Line 66  Line 106 
106   *   *
107   *    datatype tyc   *    datatype tyc
108   *      = TC_VAR of index * int   *      = TC_VAR of index * int
109   *      | TC_NVAR of tvar * depth * int    (* currently not used *)   *      | TC_NVAR of tvar * depth * int    (* NOT USED *)
110   *      | TC_PRIM of primtyc   *      | TC_PRIM of primtyc
111   *      | TC_FN of tkind list * tyc   *      | TC_FN of tkind list * tyc
112   *      | TC_APP of tyc * tyc list   *      | TC_APP of tyc * tyc list
# Line 74  Line 114 
114   *      | TC_PROJ of tyc * int   *      | TC_PROJ of tyc * int
115   *      | TC_SUM of tyc list   *      | TC_SUM of tyc list
116   *      | TC_FIX of tyc * int   *      | TC_FIX of tyc * int
117   *      | TC_ABS of tyc                    (* currently not used *)   *      | TC_WRAP of tyc                   (* used after rep. analysis only *)
118   *      | TC_BOX of tyc                    (* used by rep analysis only *)   *      | TC_ABS of tyc                    (* NOT USED *)
119   *      | TC_TUPLE of tyc list   *      | TC_BOX of tyc                    (* NOT USED *)
120   *      | TC_ARROW of rawflag * tyc list * tyc list   *      | TC_TUPLE of tyc list             (* rflag hidden *)
121     *      | TC_ARROW of fflag * tyc list * tyc list
122   *   *
123   * We treat tyc as an abstract type so we can no longer use   * We treat tyc as an abstract type so we can no longer use
124   * pattern matching. Type applications (TC_APP) and projections   * pattern matching. Type applications (TC_APP) and projections
# Line 97  Line 138 
138  val tcc_proj   : tyc * int -> tyc  val tcc_proj   : tyc * int -> tyc
139  val tcc_sum    : tyc list -> tyc  val tcc_sum    : tyc list -> tyc
140  val tcc_fix    : (int * tyc * tyc list) * int -> tyc  val tcc_fix    : (int * tyc * tyc list) * int -> tyc
141    val tcc_wrap   : tyc -> tyc
142  val tcc_abs    : tyc -> tyc  val tcc_abs    : tyc -> tyc
143  val tcc_box    : tyc -> tyc  val tcc_box    : tyc -> tyc
144  val tcc_tuple  : tyc list -> tyc  val tcc_tuple  : tyc list -> tyc
145  val tcc_arrow  : rawflag * tyc list * tyc list -> tyc  val tcc_arrow  : fflag * tyc list * tyc list -> tyc
146    
147  (** tyc deconstructors *)  (** tyc deconstructors *)
148  val tcd_var    : tyc -> index * int  val tcd_var    : tyc -> index * int
# Line 112  Line 154 
154  val tcd_proj   : tyc -> tyc * int  val tcd_proj   : tyc -> tyc * int
155  val tcd_sum    : tyc -> tyc list  val tcd_sum    : tyc -> tyc list
156  val tcd_fix    : tyc -> (int * tyc * tyc list) * int  val tcd_fix    : tyc -> (int * tyc * tyc list) * int
157    val tcd_wrap   : tyc -> tyc
158  val tcd_abs    : tyc -> tyc  val tcd_abs    : tyc -> tyc
159  val tcd_box    : tyc -> tyc  val tcd_box    : tyc -> tyc
160  val tcd_tuple  : tyc -> tyc list  val tcd_tuple  : tyc -> tyc list
161  val tcd_arrow  : tyc -> rawflag * tyc list * tyc list  val tcd_arrow  : tyc -> fflag * tyc list * tyc list
162    
163  (** tyc predicates *)  (** tyc predicates *)
164  val tcp_var    : tyc -> bool  val tcp_var    : tyc -> bool
# Line 127  Line 170 
170  val tcp_proj   : tyc -> bool  val tcp_proj   : tyc -> bool
171  val tcp_sum    : tyc -> bool  val tcp_sum    : tyc -> bool
172  val tcp_fix    : tyc -> bool  val tcp_fix    : tyc -> bool
173    val tcp_wrap   : tyc -> bool
174  val tcp_abs    : tyc -> bool  val tcp_abs    : tyc -> bool
175  val tcp_box    : tyc -> bool  val tcp_box    : tyc -> bool
176  val tcp_tuple  : tyc -> bool  val tcp_tuple  : tyc -> bool
# Line 142  Line 186 
186  val tcw_proj   : tyc * (tyc * int -> 'a) * (tyc -> 'a) -> 'a  val tcw_proj   : tyc * (tyc * int -> 'a) * (tyc -> 'a) -> 'a
187  val tcw_sum    : tyc * (tyc list -> 'a) * (tyc -> 'a) -> 'a  val tcw_sum    : tyc * (tyc list -> 'a) * (tyc -> 'a) -> 'a
188  val tcw_fix    : tyc * ((int * tyc * tyc list) * int -> 'a) * (tyc -> 'a) -> 'a  val tcw_fix    : tyc * ((int * tyc * tyc list) * int -> 'a) * (tyc -> 'a) -> 'a
189    val tcw_wrap   : tyc * (tyc -> 'a) * (tyc -> 'a) -> 'a
190  val tcw_abs    : tyc * (tyc -> 'a) * (tyc -> 'a) -> 'a  val tcw_abs    : tyc * (tyc -> 'a) * (tyc -> 'a) -> 'a
191  val tcw_box    : tyc * (tyc -> 'a) * (tyc -> 'a) -> 'a  val tcw_box    : tyc * (tyc -> 'a) * (tyc -> 'a) -> 'a
192  val tcw_tuple  : tyc * (tyc list -> 'a) * (tyc -> 'a) -> 'a  val tcw_tuple  : tyc * (tyc list -> 'a) * (tyc -> 'a) -> 'a
193  val tcw_arrow  : tyc * (rawflag * tyc list * tyc list -> 'a)  val tcw_arrow  : tyc * (fflag * tyc list * tyc list -> 'a)
194                       * (tyc -> 'a) -> 'a                       * (tyc -> 'a) -> 'a
195    
196    
# Line 157  Line 202 
202   *      | LT_STR of lty list   *      | LT_STR of lty list
203   *      | LT_FCT of lty list * lty list   *      | LT_FCT of lty list * lty list
204   *      | LT_POLY of tkind list * lty list   *      | LT_POLY of tkind list * lty list
205   *      | LT_PST of (int * lty) list         (* soon obsolete *)   *      | LT_PST of (int * lty) list            (* SOON BECOME OBSOLETE *)
206   *   *
207   * We treat lty as an abstract type so we can no longer use pattern   * We treat lty as an abstract type so we can no longer use pattern
208   * matching. The client does not need to worry about whether an lty   * matching. The client does not need to worry about whether an lty
# Line 203  Line 248 
248  val ltc_var    : index * int -> lty  val ltc_var    : index * int -> lty
249  val ltc_prim   : primtyc -> lty  val ltc_prim   : primtyc -> lty
250  val ltc_tuple  : lty list -> lty  val ltc_tuple  : lty list -> lty
251  val ltc_arrow  : rawflag * lty list * lty list -> lty  val ltc_arrow  : fflag * lty list * lty list -> lty
252    
253  (** tyc-lty deconstructors *)  (** tyc-lty deconstructors *)
254  val ltd_var    : lty -> index * int  val ltd_var    : lty -> index * int
255  val ltd_prim   : lty -> primtyc  val ltd_prim   : lty -> primtyc
256  val ltd_tuple  : lty -> lty list  val ltd_tuple  : lty -> lty list
257  val ltd_arrow  : lty -> rawflag * lty list * lty list  val ltd_arrow  : lty -> fflag * lty list * lty list
258    
259  (** tyc-lty predicates *)  (** tyc-lty predicates *)
260  val ltp_var    : lty -> bool  val ltp_var    : lty -> bool
# Line 221  Line 266 
266  val ltw_var    : lty * (index * int -> 'a) * (lty -> 'a) -> 'a  val ltw_var    : lty * (index * int -> 'a) * (lty -> 'a) -> 'a
267  val ltw_prim   : lty * (primtyc -> 'a) * (lty -> 'a) -> 'a  val ltw_prim   : lty * (primtyc -> 'a) * (lty -> 'a) -> 'a
268  val ltw_tuple  : lty * (tyc list -> 'a) * (lty -> 'a) -> 'a  val ltw_tuple  : lty * (tyc list -> 'a) * (lty -> 'a) -> 'a
269  val ltw_arrow  : lty * (rawflag * tyc list * tyc list -> 'a)  val ltw_arrow  : lty * (fflag * tyc list * tyc list -> 'a)
270                       * (lty -> 'a) -> 'a                       * (lty -> 'a) -> 'a
271    
272    
273  (*  (*
274   * The following functions are written for CPS only. If you are writing   * The following functions are written for CPS only. If you are writing
275   * writing code for FLINT, you should not use any of these functions.   * code for FLINT, you should not use any of these functions.
276   * The continuation referred here is the internal continuation introduced   * The continuation referred here is the internal continuation introduced
277   * via CPS conversion; it is different from the source-level continuation   * via CPS conversion; it is different from the source-level continuation
278   * ('a cont) or control continuation ('a control-cont) where are represented   * ('a cont) or control continuation ('a control-cont) where are represented

Legend:
Removed from v.24  
changed lines
  Added in v.45

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0