First pass on splitting stratum and opacity off of effects. WIP.

Author: graydon

doc/rust.texi

@@ -667,11 +667,12 @@ The keywords are:
 @tab @code{export}
 @tab @code{let}
 @tab @code{auto}
-@item @code{io}
-@tab @code{state}
+@item @code{state}
+@tab @code{gc}
+@tab @code{abs}
+@item @code{auth}
+@tab @code{impure}
 @tab @code{unsafe}
-@tab @code{auth}
-@tab @code{with}
 @item @code{bind}
 @tab @code{type}
 @tab @code{true}
@@ -705,8 +706,8 @@ The keywords are:
 @item @code{task}
 @tab @code{port}
 @tab @code{chan}
-@tab @code{flush}
 @tab @code{spawn}
+@tab @code{with}
 @item @code{if}
 @tab @code{else}
 @tab @code{alt}
@@ -1473,7 +1474,6 @@ operating-system processes.
 @cindex Message passing
 @cindex Send statement
 @cindex Receive statement
-@cindex Flush statement
 
 With the exception of @emph{unsafe} constructs, Rust tasks are isolated from
 interfering with one another's memory directly. Instead of manipulating shared
@@ -1515,11 +1515,7 @@ task. If too many messages are queued for transmission from a single sending
 task, without being received by a receiving task, the sending task may exceed
 its memory budget, which causes a run-time signal. To help control this
 possibility, a semi-synchronous send operation is possible, which blocks until
-there is room in the existing queue and then executes an asynchronous send. A
-full @code{flush} operation is also available, which blocks until a channel's
-queue is @emph{empty}. A @code{flush} does @emph{not} guarantee that a message
-has been @emph{received} by any particular recipient when the sending task is
-unblocked. @xref{Ref.Stmt.Flush}.
+there is room in the existing queue and then executes an asynchronous send.
 
 The asynchronous message-send operator is @code{<+}. The semi-synchronous
 message-send operator is @code{<|}. @xref{Ref.Stmt.Send}. The message-receive
@@ -2550,7 +2546,6 @@ actions.
 * Ref.Stmt.Copy::               Statement for copying a value.
 * Ref.Stmt.Spawn::              Statements for creating new tasks.
 * Ref.Stmt.Send::               Statements for sending a value into a channel.
-* Ref.Stmt.Flush::              Statement for flushing a channel queue.
 * Ref.Stmt.Recv::               Statement for receiving a value from a channel.
 * Ref.Stmt.Call::               Statement for calling a function.
 * Ref.Stmt.Bind::               Statement for binding arguments to functions.
@@ -2933,24 +2928,6 @@ chan[str] c = @dots{};
 c <| "hello, world";
 @end example
 
-@node       Ref.Stmt.Flush
-@subsection Ref.Stmt.Flush
-@c * Ref.Stmt.Flush::              Statement for flushing a channel queue.
-@cindex Flush statement
-@cindex Communication
-
-A @code{flush} statement takes a channel and blocks the flushing task until
-the channel's queue has emptied. It can be used to implement a more precise
-form of flow-control than with the send operators alone.
-
-An example of the @code{flush} statement:
-@example
-chan[str] c = @dots{};
-c <| "hello, world";
-flush c;
-@end example
-
-
 @node       Ref.Stmt.Recv
 @subsection Ref.Stmt.Recv
 @c * Ref.Stmt.Recv::           Statement for receiving a value from a channel.
@@ -3359,8 +3336,8 @@ statement following the @code{alt} when the case block completes.
 @cindex Multiplexing
 
 The simplest form of @code{alt} statement is the a @emph{communication}
-@code{alt}. The cases of a communication @code{alt}'s arms are send, receive
-and flush statements. @xref{Ref.Task.Comm}.
+@code{alt}. The cases of a communication @code{alt}'s arms are send and
+receive statements. @xref{Ref.Task.Comm}.
 
 To execute a communication @code{alt}, the runtime checks all of the ports and
 channels involved in the arms of the statement to see if any @code{case} can
@@ -3679,3 +3656,11 @@ to the task's domain; if the queue grows too big, the task will fail.
 @printindex cp
 
 @bye
+
+@c Local Variables:
+@c mode: texinfo
+@c fill-column: 78;
+@c indent-tabs-mode: nil
+@c buffer-file-coding-system: utf-8-unix
+@c compile-command: "make -k 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+@c End:

src/boot/fe/ast.ml

@@ -29,10 +29,20 @@ type slot_key =
  *)
 
 type effect =
-    PURE
-  | IO
-  | STATE
-  | UNSAFE
+    EFF_pure
+  | EFF_impure
+  | EFF_unsafe
+;;
+
+type stratum =
+    STRAT_value
+  | STRAT_state
+  | STRAT_gc
+;;
+
+type opacity =
+    OPA_transparent
+  | OPA_abstract
 ;;
 
 type mutability =
@@ -702,19 +712,56 @@ and fmt_effect
     (effect:effect)
     : unit =
   match effect with
-      PURE -> ()
-    | IO -> fmt ff "io"
-    | STATE -> fmt ff "state"
-    | UNSAFE -> fmt ff "unsafe"
+      EFF_pure -> ()
+    | EFF_impure -> fmt ff "impure"
+    | EFF_unsafe -> fmt ff "unsafe"
+
+and fmt_effect_qual
+    (ff:Format.formatter)
+    (e:effect)
+    : unit =
+  fmt_effect ff e;
+  if e <> EFF_pure then fmt ff " ";
+
+and fmt_stratum
+    (ff:Format.formatter)
+    (strat:stratum)
+    : unit =
+  match strat with
+      STRAT_value -> ()
+    | STRAT_state -> fmt ff "state"
+    | STRAT_gc -> fmt ff "gc"
+
+and fmt_stratum_qual
+    (ff:Format.formatter)
+    (s:stratum)
+    : unit =
+  fmt_stratum ff s;
+  if s <> STRAT_value then fmt ff " ";
+
+and fmt_opacity
+    (ff:Format.formatter)
+    (opa:opacity)
+    : unit =
+  match opa with
+      OPA_transparent -> ()
+    | OPA_abstract -> fmt ff "abs"
+
+and fmt_opacity_qual
+    (ff:Format.formatter)
+    (op:opacity)
+    : unit =
+  fmt_opacity ff op;
+  if op <> OPA_transparent then fmt ff " ";
+
 
 and fmt_ty_fn
     (ff:Format.formatter)
     (ident_and_params:(ident * ty_param array) option)
     (tf:ty_fn)
     : unit =
   let (tsig, ta) = tf in
-    fmt_effect ff ta.fn_effect;
-    if ta.fn_effect <> PURE then fmt ff " ";
+    fmt_effect_qual ff ta.fn_effect;
     fmt ff "%s" (if ta.fn_is_iter then "iter" else "fn");
     begin
       match ident_and_params with
@@ -763,8 +810,7 @@ and fmt_ty (ff:Format.formatter) (t:ty) : unit =
       fmt_ident_tys ff entries;
       fmt ff "@]"
 
-  | TY_param (i, e) -> (fmt_effect ff e;
-                        if e <> PURE then fmt ff " ";
+  | TY_param (i, e) -> (fmt_effect_qual ff e;
                         fmt ff "<p#%d>" i)
   | TY_native oid -> fmt ff "<native#%d>" (int_of_opaque oid)
   | TY_named n -> fmt_name ff n
@@ -789,8 +835,7 @@ and fmt_ty (ff:Format.formatter) (t:ty) : unit =
 
   | TY_obj (effect, fns) ->
       fmt_obox ff;
-      fmt_effect ff effect;
-      if effect <> PURE then fmt ff " ";
+      fmt_effect_qual ff effect;
       fmt ff "obj ";
       fmt_obr ff;
       Hashtbl.iter
@@ -1584,8 +1629,7 @@ and fmt_slice (ff:Format.formatter) (slice:slice) : unit =
 
 and fmt_decl_param (ff:Format.formatter) (param:ty_param) : unit =
   let (ident, (i, e)) = param in
-  fmt_effect ff e;
-  if e <> PURE then fmt ff " ";
+  fmt_effect_qual ff e;
   fmt_ident ff ident;
   fmt ff "=<p#%d>" i
 
@@ -1608,10 +1652,6 @@ and fmt_ident_and_params
   fmt_ident ff id;
   fmt_decl_params ff params
 
-and fmt_effect_qual (ff:Format.formatter) (e:effect) : unit =
-  fmt_effect ff e;
-  if e <> PURE then fmt ff " ";
-
 and fmt_fn
     (ff:Format.formatter)
     (id:ident)

src/boot/fe/cexp.ml

@@ -181,7 +181,7 @@ and parse_cexp (ps:pstate) : cexp =
                   fun (ident, item) ->
                     htab_put items ident item
                 end
-                (Item.parse_mod_item_from_signature ps)
+                (Item.parse_native_mod_item_from_signature ps)
             in
               ignore (bracketed_zero_or_more
                         LBRACE RBRACE None get_item ps);

src/boot/fe/fuzz.ml

@@ -104,7 +104,7 @@ let rec generate_mod_item (mis:mod_items) (cx:ctxt) : unit =
     match Random.int 2 with
         0 ->
           let ty = generate_ty cx in
-          let eff = PURE in
+          let eff = Ast.EFF_pure in
             decl (MOD_ITEM_type (eff, ty))
       | _ ->
           let mis' = Hashtbl.create 0 in

src/boot/fe/item.ml

@@ -154,8 +154,6 @@ and parse_stmts (ps:pstate) : Ast.stmt array =
     if (Array.length arr) == 0 then
       raise (err "statement does nothing" ps);
     arr
-        
-    
 
 (*
  * We have no way to parse a single Ast.stmt; any incoming syntactic statement
@@ -605,7 +603,11 @@ and parse_stmts_including_none (ps:pstate) : Ast.stmt array =
             expect ps SEMI;
             spans ps stmts apos (Ast.STMT_join lval)
 
-      | IO | STATE | UNSAFE | MOD | OBJ | TAG | TYPE | FN | USE | NATIVE ->
+
+       | STATE | GC
+       | IMPURE | UNSAFE
+       | ABS | NATIVE
+       | MOD | OBJ | TAG | TYPE | FN | USE ->
           let items = ctxt "stmt: decl" parse_mod_item ps in
           let bpos = lexpos ps in
             Array.map
@@ -689,6 +691,8 @@ and parse_stmts_including_none (ps:pstate) : Ast.stmt array =
 
 and parse_ty_param (iref:int ref) (ps:pstate) : Ast.ty_param identified =
   let apos = lexpos ps in
+  let _ = Pexp.parse_opacity ps in
+  let _ = Pexp.parse_stratum ps in
   let e = Pexp.parse_effect ps in
   let ident = Pexp.parse_ident ps in
   let i = !iref in
@@ -851,7 +855,7 @@ and parse_obj_item
       do
         let apos = lexpos ps in
           match peek ps with
-              IO | STATE | UNSAFE | FN | ITER ->
+              IMPURE | UNSAFE | FN | ITER ->
                 let effect = Pexp.parse_effect ps in
                 let is_iter = (peek ps) = ITER in
                   bump ps;
@@ -986,7 +990,10 @@ and parse_mod_item (ps:pstate)
 
     match peek ps with
 
-        IO | STATE | UNSAFE | TYPE | OBJ | TAG | FN | ITER ->
+        STATE | GC | IMPURE | UNSAFE | ABS
+      | TYPE | OBJ | TAG | FN | ITER ->
+          let _ = Pexp.parse_opacity ps in
+          let _ = Pexp.parse_stratum ps in
           let effect = Pexp.parse_effect ps in
             begin
               match peek ps with
@@ -1044,7 +1051,7 @@ and parse_mod_item (ps:pstate)
               expect ps MOD;
               let ident = Pexp.parse_ident ps in
               let path = parse_lib_name ident in
-              let items = parse_mod_items_from_signature ps in
+              let items = parse_native_mod_items_from_signature ps in
               let bpos = lexpos ps in
               let rlib = REQUIRED_LIB_c { required_libname = path;
                                           required_prefix = ps.pstate_depth }
@@ -1056,7 +1063,7 @@ and parse_mod_item (ps:pstate)
           end
       | _ -> raise (unexpected ps)
 
-and parse_mod_items_header_from_signature (ps:pstate) : Ast.mod_view =
+and parse_native_mod_header_from_signature (ps:pstate) : Ast.mod_view =
   let exports = Hashtbl.create 0 in
     while (peek ps = EXPORT)
     do
@@ -1068,36 +1075,36 @@ and parse_mod_items_header_from_signature (ps:pstate) : Ast.mod_view =
     then htab_put exports Ast.EXPORT_all_decls ();
     {empty_view with Ast.view_exports = exports}
 
-and parse_mod_items_from_signature
+and parse_native_mod_items_from_signature
     (ps:pstate)
     : (Ast.mod_view * Ast.mod_items) =
   expect ps LBRACE;
-  let view  = parse_mod_items_header_from_signature ps in
+  let view  = parse_native_mod_header_from_signature ps in
   let items = Hashtbl.create 0 in
     while not (peek ps = RBRACE)
     do
       Array.iter
         (fun (ident, item) ->
            htab_put items ident item)
         (ctxt "mod items from sig: mod item"
-           parse_mod_item_from_signature ps)
+           parse_native_mod_item_from_signature ps)
     done;
     expect ps RBRACE;
     (view,items)
 
-and parse_mod_item_from_signature (ps:pstate)
+and parse_native_mod_item_from_signature (ps:pstate)
     : (Ast.ident * Ast.mod_item) array =
   let apos = lexpos ps in
     match peek ps with
         MOD ->
           bump ps;
           let (ident, params) = parse_ident_and_params ps "mod signature" in
-          let items = parse_mod_items_from_signature ps in
+          let items = parse_native_mod_items_from_signature ps in
           let bpos = lexpos ps in
             [| (ident,
                 span ps apos bpos (decl params (Ast.MOD_ITEM_mod items))) |]
 
-      | IO | STATE | UNSAFE | FN | ITER ->
+      | IMPURE | UNSAFE | FN | ITER ->
           let effect = Pexp.parse_effect ps in
           let is_iter = (peek ps) = ITER in
             bump ps;
@@ -1142,7 +1149,7 @@ and parse_mod_item_from_signature (ps:pstate)
           expect ps SEMI;
           let bpos = lexpos ps in
             [| (ident, span ps apos bpos
-                  (decl params (Ast.MOD_ITEM_type (Ast.UNSAFE, t)))) |]
+                  (decl params (Ast.MOD_ITEM_type (Ast.EFF_unsafe, t)))) |]
 
     | _ -> raise (unexpected ps)
 

src/boot/fe/lexer.mll

@@ -95,8 +95,12 @@
                 ("claim", CLAIM);
                 ("prove", PROVE);
 
-                ("io", IO);
+                ("abs", ABS);
+
                 ("state", STATE);
+                ("gc", GC);
+
+                ("impure", IMPURE);
                 ("unsafe", UNSAFE);
 
                 ("native", NATIVE);