Deprecate CLOSURE => <durable>, PROC, PROCEDURE

This commit makes the next step toward FUNCTION! and CLOSURE!
unification by eliminating the CLOSURE! type, in favor of the ability
to mark a function's arguments <durable>.

(Note: The name <durable> is tentative, and at present durable is "all
or nothing"...it is not possible to specify some arguments or locals
as surviving and others not.  However, that selectivity is planned in
the design and should be added at a later date.)

Marking a function's arguments <durable> currently has the other effect
historically of a closure--to give them specific binding.  This feature
is planned to be implemented in a way that does not require a deep
copy of the function's body on each execution as closure does--so all
FUNCTION!s will have that property.  Only the selection of individual
arguments as durable will remain.

Taking the place of CLOS and CLOSURE are the PROC and PROCEDURE
function generators.  Instead of RETURN they have a definitional-scoped
0-arity function called LEAVE.  This returns UNSET! always, and in
addition they suppress any return value from falling out:

     >> foo: procedure [] [leave print "This won't print"]
     >> foo
     ; No result

     >> foo: proc [y] [y + 20]
     >> foo 10
     ; No result

Author: hostilefork

src/boot/root.r

@@ -29,6 +29,7 @@ empty-block     ; a value that is an empty BLOCK!
 transparent-tag ; func w/o definitional return, ignores non-definitional ones
 infix-tag       ; func is treated as "infix" (first parameter comes before it)
 local-tag       ; marks the beginning of a list of "pure locals"
+durable-tag     ; !!! In progress - argument word lookup survives call ending
 
 ;; Natives can usually be identified by their code pointers and addresses
 ;; (e.g. `VAL_FUNC_CODE(native) == &N_parse`) and know their own values via
@@ -38,6 +39,7 @@ local-tag       ; marks the beginning of a list of "pure locals"
 ;; (PARSE just wants access to its D_FUNC more convenient from a nested call)
 
 return-native
+leave-native
 parse-native
 
 ;; The BREAKPOINT instruction needs to be able to re-transmit a RESUME
@@ -49,14 +51,16 @@ parse-native
 resume-native
 quit-native
 
-;; The FUNC and CLOS function generators are native code, and quick access
-;; to a block containing [RETURN:] is useful to share across all of the
+;; The FUNC and PROC function generators are native code, and quick access
+;; to a block of [RETURN:] or [LEAVE:] is useful to share across all of the
 ;; instances of functions like those created by DOES.  Having a filled
 ;; REBVAL of the word alone saves a call to Val_Init_Word_Unbound with
 ;; the symbol as well.
 
 return-set-word
 return-block
+leave-set-word
+leave-block
 
 boot            ; boot block defined in boot.r (GC'd after boot is done)
 

src/boot/sysobj.r

@@ -177,7 +177,7 @@ script: context [
 
 standard: context [
 
-    ; FUNC+CLOS implement a native-optimized variant of a function generator.
+    ; FUNC+PROC implement a native-optimized variant of a function generator.
     ; This is the body template that it provides as the code *equivalent* of
     ; what it is doing (via a more specialized/internal method).  Though
     ; the only "real" body stored and used is the one the user provided
@@ -195,6 +195,15 @@ standard: context [
         #BODY
     ]
 
+    proc-body: [
+        leave: make function! [
+            [{Leaves a procedure, giving no result to the caller.}]
+            [exit/from (context-of 'leave)]
+        ]
+        #BODY
+        comment {No return value.}
+    ]
+
     error: context [ ; Template used for all errors:
         code: none
         type: 'user

src/boot/types.r

@@ -94,7 +94,6 @@ native      (function)  *       -       -       *       function
 action      (function)  *       -       -       *       function
 routine     (routine)   *       -       -       *       function
 command     (function)  -       -       -       *       function
-closure     (function)  *       -       -       *       function
 function    (function)  *       -       -       *       function
 
 object      context     *       f*      *       *       context

src/boot/typespec.r

@@ -21,7 +21,6 @@ binary      ["string series of bytes" string]
 bitset      ["set of bit flags" string]
 block       ["array of values that blocks evaluation unless DO is used" block]
 char        ["8bit and 16bit character" scalar]
-closure     ["function with persistent locals (indefinite extent)" function]
 callback    ["function to be called from C" scalar]
 datatype    ["type of datatype" symbol]
 date        ["day, month, year, time of day, and timezone" scalar]

src/boot/words.r

@@ -127,6 +127,7 @@ exit
 quit
 ;break ;-- covered by parse below
 ;return ;-- covered by parse below
+leave ;-- for PROC
 continue
 
 ; PARSE - These words must not be reserved above!!  The range of consecutive

src/core/b-init.c

@@ -767,19 +767,26 @@ static void Init_Root_Context(void)
     SERIES_SET_FLAG(VAL_SERIES(ROOT_EMPTY_BLOCK), OPT_SER_LOCKED);
     SERIES_SET_FLAG(VAL_SERIES(ROOT_EMPTY_BLOCK), OPT_SER_FIXED_SIZE);
 
-    // Used by FUNC and CLOS generators: RETURN:
+    // Used by FUNC and PROC generators - RETURN: & LEAVE:
+    //
     Val_Init_Word(ROOT_RETURN_SET_WORD, REB_SET_WORD, SYM_RETURN);
+    Val_Init_Word(ROOT_LEAVE_SET_WORD, REB_SET_WORD, SYM_LEAVE);
 
     // Make a series that's just [return:], that is made often in function
     // spec blocks (when the original spec was just []).  Unlike the paramlist
     // a function spec doesn't need unique mutable identity, so a shared
-    // series saves on allocation time and space...
+    // series saves on allocation time and space...do the same for [leave:]
     //
     Val_Init_Block(ROOT_RETURN_BLOCK, Make_Array(1));
     Append_Value(VAL_ARRAY(ROOT_RETURN_BLOCK), ROOT_RETURN_SET_WORD);
     ARRAY_SET_FLAG(VAL_ARRAY(ROOT_RETURN_BLOCK), OPT_SER_LOCKED);
     ARRAY_SET_FLAG(VAL_ARRAY(ROOT_RETURN_BLOCK), OPT_SER_FIXED_SIZE);
 
+    Val_Init_Block(ROOT_LEAVE_BLOCK, Make_Array(1));
+    Append_Value(VAL_ARRAY(ROOT_LEAVE_BLOCK), ROOT_LEAVE_SET_WORD);
+    ARRAY_SET_FLAG(VAL_ARRAY(ROOT_LEAVE_BLOCK), OPT_SER_LOCKED);
+    ARRAY_SET_FLAG(VAL_ARRAY(ROOT_LEAVE_BLOCK), OPT_SER_FIXED_SIZE);
+
     // We can't actually put an end value in the middle of a block, so we poke
     // this one into a program global.  We also dynamically allocate it in
     // order to get uninitialized memory for everything but the header (if
@@ -1389,6 +1396,7 @@ void Init_Core(REBARGS *rargs)
     const REBYTE transparent[] = "transparent";
     const REBYTE infix[] = "infix";
     const REBYTE local[] = "local";
+    const REBYTE durable[] = "durable";
 
     REBVAL result;
     VAL_INIT_WRITABLE_DEBUG(&result);
@@ -1552,6 +1560,13 @@ void Init_Core(REBARGS *rargs)
     SERIES_SET_FLAG(VAL_SERIES(ROOT_LOCAL_TAG), OPT_SER_FIXED_SIZE);
     SERIES_SET_FLAG(VAL_SERIES(ROOT_LOCAL_TAG), OPT_SER_LOCKED);
 
+    Val_Init_Tag(
+        ROOT_DURABLE_TAG,
+        Append_UTF8(NULL, durable, LEN_BYTES(durable))
+    );
+    SERIES_SET_FLAG(VAL_SERIES(ROOT_DURABLE_TAG), OPT_SER_FIXED_SIZE);
+    SERIES_SET_FLAG(VAL_SERIES(ROOT_DURABLE_TAG), OPT_SER_LOCKED);
+
     // Special pre-made errors:
     Val_Init_Error(TASK_STACK_ERROR, Error(RE_STACK_OVERFLOW));
     Val_Init_Error(TASK_HALT_ERROR, Error(RE_HALT));