FEAT: new AS native function for series coercion into a compatible datatype without copying it

Example:
```
>> p: as path! b: [a b]
== a/b

>> append b 'c
== [a b c]

>> p
== a/b/c
```

Author: Oldes

src/boot/errors.r

@@ -66,6 +66,7 @@ Script: [
 	no-op-arg:          [:arg1 {operator is missing an argument}]
 	invalid-data:       [{data not in correct format:} :arg1]
 	not-same-type:      {values must be of the same type}
+	not-same-class:     [{cannot coerce} :arg1 {to} :arg2]
 	not-related:        [{incompatible argument for} :arg1 {of} :arg2]
 	bad-func-def:       [{invalid function definition:} :arg1]
 	bad-func-arg:       [{function argument} :arg1 {is not valid}] ; can be a number
@@ -126,7 +127,6 @@ Script: [
 
 	invalid-handle:     {invalid handle}
 	invalid-value-for:  [{invalid value} :arg1 {for:} :arg2]
-
 ]
 
 Math: [

src/boot/natives.r

@@ -342,6 +342,12 @@ while: native [
 ;	string [any-string!]
 ;]
 
+as: native [
+	{Coerce a series into a compatible datatype without copying it.}
+	type [any-block! any-string! datatype!] "The datatype or example value"
+	spec [any-block! any-string!] "The series to coerce"
+]
+
 bind: native [
 	{Binds words to the specified context.}
 	word [block! any-word!] {A word or block (modified) (returned)}

src/core/n-data.c

@@ -212,6 +212,26 @@ static int Check_Char_Range(REBVAL *val, REBINT limit)
 }
 
 
+/***********************************************************************
+**
+*/	REBNATIVE(as)
+/*
+***********************************************************************/
+{
+	REBVAL *type = D_ARG(1);
+	REBVAL *spec = D_ARG(2);
+	REBCNT target = IS_DATATYPE(type)? VAL_DATATYPE(type) : VAL_TYPE(type);
+	if ((ANY_BLOCK(spec) && ANY_BLOCK_TYPE(target)) || (ANY_STR(spec) && ANY_STR_TYPE(target))) {
+		SET_TYPE(spec, target);
+	} else {
+		Set_Datatype(spec, VAL_TYPE(spec));
+		Set_Datatype(type, target);
+		Trap2(RE_NOT_SAME_CLASS, spec, type);
+	}
+	return R_ARG2;
+}
+
+
 /***********************************************************************
 **
 */	REBNATIVE(as_pair)

src/include/sys-value.h

@@ -1211,6 +1211,9 @@ typedef struct Reb_All {
 #define ANY_EVAL_BLOCK(v)	(VAL_TYPE(v) >= REB_BLOCK  && VAL_TYPE(v) <= REB_PAREN)
 #define ANY_OBJECT(v)		(VAL_TYPE(v) >= REB_OBJECT && VAL_TYPE(v) <= REB_PORT)
 
+#define ANY_BLOCK_TYPE(t)   (t >= REB_BLOCK   && t <= REB_LIT_PATH)
+#define ANY_STR_TYPE(t)     (t >= REB_STRING  && t <= REB_TAG)
+
 #pragma pack()
 
 #endif // value.h

src/tests/units/series-test.r3

@@ -450,6 +450,57 @@ Rebol [
 
 ===end-group===
 
+===start-group=== "AS coercion"
+
+--test-- "AS datatype! any-string!"
+	s: "hell"
+	--assert file?  f: as file!  s
+	--assert email? e: as email! s
+	--assert url?   u: as url!   s
+	--assert tag?   t: as tag!   s
+	append s #"o"
+	--assert f = %hello
+	--assert e = to-email %hello
+	--assert u = #[url! "hello"]
+	--assert t = <hello>
+
+--test-- "AS datatype! any-block!"
+	b: [a b]
+	--assert paren?    pa: as paren!    b
+	--assert path?     p:  as path!     b
+	--assert set-path? sp: as set-path! b
+	--assert get-path? gp: as get-path! b
+	--assert lit-path? lp: as lit-path! b
+	append b 'c
+	--assert pa = quote (a b c)
+	--assert p  = quote a/b/c
+	--assert sp = quote a/b/c:
+	--assert gp = quote :a/b/c
+	--assert lp = quote 'a/b/c
+
+--test-- "AS example any-string!"
+	s: "hell"
+	--assert file?  f: as %file  s
+	--assert email? e: as e@mail s
+	--assert url?   u: as #[url! ""] s
+	--assert tag?   t: as <tag>  s
+
+--test-- "AS with protect"
+	b: protect [a b]
+	--assert path? try [p: as path! b]
+	--assert error? e: try [append b 'c]
+	--assert e/id = 'protected
+	--assert error? e: try [append p 'c]
+	--assert e/id = 'protected
+
+--test-- "AS coercion error"
+	--assert error? e: try [as string! []]
+	--assert e/id = 'not-same-class
+	--assert error? e: try [as block! ""]
+	--assert e/id = 'not-same-class
+
+===end-group===
+
 ;-- VECTOR related tests moved to %vector-test.r3
 
 ~~~end-file~~~