kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Short circuit functions if empty: array, map, string.

Browse Source
This commit is contained in:
Stephen Chung 2021-09-20 18:35:23 +08:00
parent 6e7fbfa66f
commit adbe9a292e
3 changed files with 352 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
src/packages/array_basic.rs
View File

@ -27,15 +27,29 @@ mod array_functions {
}
#[rhai_fn(name = "append", name = "+=")]
pub fn append(array: &mut Array, y: Array) {
array.extend(y);
if !y.is_empty() {
if array.is_empty() {
*array = y;
} else {
array.extend(y);
}
}
}
#[rhai_fn(name = "+")]
pub fn concat(mut array: Array, y: Array) -> Array {
array.extend(y);
if !y.is_empty() {
if array.is_empty() {
array = y;
} else {
array.extend(y);
}
}
array
}
pub fn insert(array: &mut Array, position: INT, item: Dynamic) {
if position < 0 {
if array.is_empty() {
array.push(item);
} else if position < 0 {
if let Some(n) = position.checked_abs() {
if n as usize > array.len() {
array.insert(0, item);
@ -46,7 +60,7 @@ mod array_functions {
array.insert(0, item);
}
} else if (position as usize) >= array.len() {
push(array, item);
array.push(item);
} else {
array.insert(position as usize, item);
}
@ -58,61 +72,78 @@ mod array_functions {
len: INT,
item: Dynamic,
) -> Result<(), Box<EvalAltResult>> {
if len <= 0 {
return Ok(());
}
// Check if array will be over max size limit
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_array_size() > 0
&& len > 0
&& (len as usize) > _ctx.engine().max_array_size()
{
if _ctx.engine().max_array_size() > 0 && (len as usize) > _ctx.engine().max_array_size() {
return EvalAltResult::ErrorDataTooLarge("Size of array".to_string(), Position::NONE)
.into();
}
if len > 0 && len as usize > array.len() {
if len as usize > array.len() {
array.resize(len as usize, item);
}
Ok(())
}
pub fn pop(array: &mut Array) -> Dynamic {
array.pop().unwrap_or_else(|| ().into())
if array.is_empty() {
Dynamic::UNIT
} else {
array.pop().unwrap_or_else(|| Dynamic::UNIT)
}
}
pub fn shift(array: &mut Array) -> Dynamic {
if array.is_empty() {
().into()
Dynamic::UNIT
} else {
array.remove(0)
}
}
pub fn remove(array: &mut Array, len: INT) -> Dynamic {
if len < 0 || (len as usize) >= array.len() {
().into()
Dynamic::UNIT
} else {
array.remove(len as usize)
}
}
pub fn clear(array: &mut Array) {
array.clear();
if !array.is_empty() {
array.clear();
}
}
pub fn truncate(array: &mut Array, len: INT) {
if len >= 0 {
array.truncate(len as usize);
} else {
array.clear();
if !array.is_empty() {
if len >= 0 {
array.truncate(len as usize);
} else {
array.clear();
}
}
}
pub fn chop(array: &mut Array, len: INT) {
if len as usize >= array.len() {
} else if len >= 0 {
array.drain(0..array.len() - len as usize);
} else {
array.clear();
if !array.is_empty() && len as usize >= array.len() {
if len >= 0 {
array.drain(0..array.len() - len as usize);
} else {
array.clear();
}
}
}
pub fn reverse(array: &mut Array) {
array.reverse();
if !array.is_empty() {
array.reverse();
}
}
pub fn splice(array: &mut Array, start: INT, len: INT, replace: Array) {
if array.is_empty() {
*array = replace;
return;
}
let start = if start < 0 {
let arr_len = array.len();
start
@ -136,18 +167,22 @@ mod array_functions {
array.splice(start..start + len, replace.into_iter());
}
pub fn extract(array: &mut Array, start: INT, len: INT) -> Array {
if array.is_empty() || len <= 0 {
return Array::new();
}
let start = if start < 0 {
let arr_len = array.len();
start
.checked_abs()
.map_or(0, |n| arr_len - (n as usize).min(arr_len))
} else if start as usize >= array.len() {
return Default::default();
return Array::new();
} else {
start as usize
};
let len = if len < 0 {
let len = if len <= 0 {
0
} else if len as usize > array.len() - start {
array.len() - start
@ -155,17 +190,25 @@ mod array_functions {
len as usize
};
array[start..start + len].to_vec()
if len == 0 {
Array::new()
} else {
array[start..start + len].to_vec()
}
}
#[rhai_fn(name = "extract")]
pub fn extract_tail(array: &mut Array, start: INT) -> Array {
if array.is_empty() {
return Array::new();
}
let start = if start < 0 {
let arr_len = array.len();
start
.checked_abs()
.map_or(0, |n| arr_len - (n as usize).min(arr_len))
} else if start as usize >= array.len() {
return Default::default();
return Array::new();
} else {
start as usize
};
@ -174,7 +217,9 @@ mod array_functions {
}
#[rhai_fn(name = "split")]
pub fn split_at(array: &mut Array, start: INT) -> Array {
if start < 0 {
if array.is_empty() {
Array::new()
} else if start < 0 {
if let Some(n) = start.checked_abs() {
if n as usize > array.len() {
mem::take(array)
@ -187,7 +232,7 @@ mod array_functions {
mem::take(array)
}
} else if start as usize >= array.len() {
Default::default()
Array::new()
} else {
let mut result = Array::new();
result.extend(array.drain(start as usize..));
@ -200,6 +245,10 @@ mod array_functions {
array: &mut Array,
mapper: FnPtr,
) -> Result<Array, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(array.clone());
}
let mut ar = Array::with_capacity(array.len());
for (i, item) in array.iter().enumerate() {
@ -233,6 +282,10 @@ mod array_functions {
array: &mut Array,
filter: FnPtr,
) -> Result<Array, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(array.clone());
}
let mut ar = Array::new();
for (i, item) in array.iter().enumerate() {
@ -269,6 +322,10 @@ mod array_functions {
array: &mut Array,
value: Dynamic,
) -> Result<bool, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(false);
}
for item in array.iter_mut() {
if ctx
.call_fn_dynamic_raw(OP_EQUALS, true, &mut [item, &mut value.clone()])
@ -300,7 +357,11 @@ mod array_functions {
array: &mut Array,
value: Dynamic,
) -> Result<INT, Box<EvalAltResult>> {
index_of_starting_from(ctx, array, value, 0)
if array.is_empty() {
Ok(-1)
} else {
index_of_starting_from(ctx, array, value, 0)
}
}
#[rhai_fn(name = "index_of", return_raw, pure)]
pub fn index_of_starting_from(
@ -309,6 +370,10 @@ mod array_functions {
value: Dynamic,
start: INT,
) -> Result<INT, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(-1);
}
let start = if start < 0 {
let arr_len = array.len();
start
@ -351,7 +416,11 @@ mod array_functions {
array: &mut Array,
filter: FnPtr,
) -> Result<INT, Box<EvalAltResult>> {
index_of_filter_starting_from(ctx, array, filter, 0)
if array.is_empty() {
Ok(-1)
} else {
index_of_filter_starting_from(ctx, array, filter, 0)
}
}
#[rhai_fn(name = "index_of", return_raw, pure)]
pub fn index_of_filter_starting_from(
@ -360,6 +429,10 @@ mod array_functions {
filter: FnPtr,
start: INT,
) -> Result<INT, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(-1);
}
let start = if start < 0 {
let arr_len = array.len();
start
@ -405,6 +478,10 @@ mod array_functions {
array: &mut Array,
filter: FnPtr,
) -> Result<bool, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(false);
}
for (i, item) in array.iter().enumerate() {
if filter
.call_dynamic(&ctx, None, [item.clone()])
@ -439,6 +516,10 @@ mod array_functions {
array: &mut Array,
filter: FnPtr,
) -> Result<bool, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(true);
}
for (i, item) in array.iter().enumerate() {
if !filter
.call_dynamic(&ctx, None, [item.clone()])
@ -473,6 +554,10 @@ mod array_functions {
array: &mut Array,
reducer: FnPtr,
) -> Result<Dynamic, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(Dynamic::UNIT);
}
let mut result = Dynamic::UNIT;
for (i, item) in array.iter().enumerate() {
@ -505,6 +590,10 @@ mod array_functions {
reducer: FnPtr,
initial: Dynamic,
) -> Result<Dynamic, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(initial);
}
let mut result = initial;
for (i, item) in array.iter().enumerate() {
@ -536,6 +625,10 @@ mod array_functions {
array: &mut Array,
reducer: FnPtr,
) -> Result<Dynamic, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(Dynamic::UNIT);
}
let mut result = Dynamic::UNIT;
for (i, item) in array.iter().enumerate().rev() {
@ -568,6 +661,10 @@ mod array_functions {
reducer: FnPtr,
initial: Dynamic,
) -> Result<Dynamic, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(initial);
}
let mut result = initial;
for (i, item) in array.iter().enumerate().rev() {
@ -599,6 +696,10 @@ mod array_functions {
array: &mut Array,
comparer: FnPtr,
) -> Result<(), Box<EvalAltResult>> {
if array.is_empty() {
return Ok(());
}
array.sort_by(|x, y| {
comparer
.call_dynamic(&ctx, None, [x.clone(), y.clone()])
@ -621,6 +722,10 @@ mod array_functions {
array: &mut Array,
filter: FnPtr,
) -> Result<Array, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(Array::new());
}
let mut drained = Array::with_capacity(array.len());
let mut i = 0;
@ -660,18 +765,22 @@ mod array_functions {
}
#[rhai_fn(name = "drain")]
pub fn drain_range(array: &mut Array, start: INT, len: INT) -> Array {
if array.is_empty() || len <= 0 {
return Array::new();
}
let start = if start < 0 {
let arr_len = array.len();
start
.checked_abs()
.map_or(0, |n| arr_len - (n as usize).min(arr_len))
} else if start as usize >= array.len() {
return Default::default();
return Array::new();
} else {
start as usize
};
let len = if len < 0 {
let len = if len <= 0 {
0
} else if len as usize > array.len() - start {
array.len() - start
@ -687,6 +796,10 @@ mod array_functions {
array: &mut Array,
filter: FnPtr,
) -> Result<Array, Box<EvalAltResult>> {
if array.is_empty() {
return Ok(Array::new());
}
let mut drained = Array::new();
let mut i = 0;
@ -726,6 +839,10 @@ mod array_functions {
}
#[rhai_fn(name = "retain")]
pub fn retain_range(array: &mut Array, start: INT, len: INT) -> Array {
if array.is_empty() || len <= 0 {
return Array::new();
}
let start = if start < 0 {
let arr_len = array.len();
start

79
src/packages/map_basic.rs
View File

@ -17,32 +17,56 @@ def_package!(crate:BasicMapPackage:"Basic object map utilities.", lib, {
mod map_functions {
#[rhai_fn(name = "has", pure)]
pub fn contains(map: &mut Map, prop: ImmutableString) -> bool {
map.contains_key(prop.as_str())
if map.is_empty() {
false
} else {
map.contains_key(prop.as_str())
}
}
#[rhai_fn(pure)]
pub fn len(map: &mut Map) -> INT {
map.len() as INT
}
pub fn clear(map: &mut Map) {
map.clear();
if !map.is_empty() {
map.clear();
}
}
pub fn remove(map: &mut Map, name: ImmutableString) -> Dynamic {
map.remove(name.as_str()).unwrap_or_else(|| ().into())
if !map.is_empty() {
map.remove(name.as_str()).unwrap_or_else(|| Dynamic::UNIT)
} else {
Dynamic::UNIT
}
}
#[rhai_fn(name = "mixin", name = "+=")]
pub fn mixin(map: &mut Map, map2: Map) {
map.extend(map2.into_iter());
if !map2.is_empty() {
map.extend(map2.into_iter());
}
}
#[rhai_fn(name = "+")]
pub fn merge(map1: Map, map2: Map) -> Map {
let mut map1 = map1;
map1.extend(map2.into_iter());
map1
if map2.is_empty() {
map1
} else if map1.is_empty() {
map2
} else {
let mut map1 = map1;
map1.extend(map2.into_iter());
map1
}
}
pub fn fill_with(map: &mut Map, map2: Map) {
map2.into_iter().for_each(|(key, value)| {
map.entry(key).or_insert(value);
});
if !map2.is_empty() {
if map.is_empty() {
*map = map2;
} else {
map2.into_iter().for_each(|(key, value)| {
map.entry(key).or_insert(value);
});
}
}
}
#[rhai_fn(name = "==", return_raw, pure)]
pub fn equals(
@ -53,23 +77,22 @@ mod map_functions {
if map1.len() != map2.len() {
return Ok(false);
}
if map1.is_empty() {
return Ok(true);
}
let mut map2 = map2;
if !map1.is_empty() {
let mut map2 = map2;
for (m1, v1) in map1.iter_mut() {
if let Some(v2) = map2.get_mut(m1) {
let equals = ctx
.call_fn_dynamic_raw(OP_EQUALS, true, &mut [v1, v2])
.map(|v| v.as_bool().unwrap_or(false))?;
for (m1, v1) in map1.iter_mut() {
if let Some(v2) = map2.get_mut(m1) {
let equals = ctx
.call_fn_dynamic_raw(OP_EQUALS, true, &mut [v1, v2])
.map(|v| v.as_bool().unwrap_or(false))?;
if !equals {
if !equals {
return Ok(false);
}
} else {
return Ok(false);
}
} else {
return Ok(false);
}
}
@ -88,11 +111,19 @@ mod map_functions {
pub mod indexing {
#[rhai_fn(pure)]
pub fn keys(map: &mut Map) -> Array {
map.keys().cloned().map(Into::<Dynamic>::into).collect()
if map.is_empty() {
Array::new()
} else {
map.keys().cloned().map(Into::<Dynamic>::into).collect()
}
}
#[rhai_fn(pure)]
pub fn values(map: &mut Map) -> Array {
map.values().cloned().collect()
if map.is_empty() {
Array::new()
} else {
map.values().cloned().collect()
}
}
}
}

227
src/packages/string_more.rs
View File

@ -66,11 +66,19 @@ mod string_functions {
#[rhai_fn(name = "len", get = "len")]
pub fn len(string: &str) -> INT {
string.chars().count() as INT
if string.is_empty() {
0
} else {
string.chars().count() as INT
}
}
#[rhai_fn(name = "bytes", get = "bytes")]
pub fn bytes(string: &str) -> INT {
string.len() as INT
if string.is_empty() {
0
} else {
string.len() as INT
}
}
pub fn remove(string: &mut ImmutableString, sub_string: ImmutableString) {
*string -= sub_string;
@ -80,7 +88,9 @@ mod string_functions {
*string -= character;
}
pub fn clear(string: &mut ImmutableString) {
string.make_mut().clear();
if !string.is_empty() {
string.make_mut().clear();
}
}
pub fn truncate(string: &mut ImmutableString, len: INT) {
if len > 0 {
@ -88,7 +98,7 @@ mod string_functions {
let copy = string.make_mut();
copy.clear();
copy.extend(chars.into_iter().take(len as usize));
} else {
} else if !string.is_empty() {
string.make_mut().clear();
}
}
@ -99,11 +109,14 @@ mod string_functions {
*string = trimmed.to_string().into();
}
}
#[rhai_fn(return_raw)]
pub fn pop(string: &mut ImmutableString) -> Result<char, Box<EvalAltResult>> {
match string.make_mut().pop() {
Some(c) => Ok(c.into()),
None => EvalAltResult::ErrorStringBounds(0, 0, Position::NONE).into(),
pub fn pop(string: &mut ImmutableString) -> Dynamic {
if string.is_empty() {
Dynamic::UNIT
} else {
match string.make_mut().pop() {
Some(c) => c.into(),
None => Dynamic::UNIT,
}
}
}
#[rhai_fn(name = "pop")]
@ -112,7 +125,7 @@ mod string_functions {
string: &mut ImmutableString,
len: INT,
) -> ImmutableString {
if len <= 0 {
if string.is_empty() || len <= 0 {
return ctx.engine().empty_string.clone();
}
@ -128,17 +141,29 @@ mod string_functions {
chars.into_iter().rev().collect::<SmartString>().into()
}
pub fn to_upper(string: &str) -> ImmutableString {
string.to_uppercase().into()
pub fn to_upper(string: ImmutableString) -> ImmutableString {
if string.is_empty() {
string
} else {
string.to_uppercase().into()
}
}
pub fn make_upper(string: &mut ImmutableString) {
*string = to_upper(string);
if !string.is_empty() {
*string = string.to_uppercase().into();
}
}
pub fn to_lower(string: &str) -> ImmutableString {
string.to_lowercase().into()
pub fn to_lower(string: ImmutableString) -> ImmutableString {
if string.is_empty() {
string
} else {
string.to_lowercase().into()
}
}
pub fn make_lower(string: &mut ImmutableString) {
*string = to_lower(string);
if !string.is_empty() {
*string = string.to_lowercase().into();
}
}
#[rhai_fn(name = "to_upper")]
@ -174,6 +199,10 @@ mod string_functions {
#[rhai_fn(name = "index_of")]
pub fn index_of_char_starting_from(string: &str, character: char, start: INT) -> INT {
if string.is_empty() {
return -1;
}
let start = if start < 0 {
if let Some(n) = start.checked_abs() {
let chars: Vec<_> = string.chars().collect();
@ -209,13 +238,21 @@ mod string_functions {
}
#[rhai_fn(name = "index_of")]
pub fn index_of_char(string: &str, character: char) -> INT {
string
.find(character)
.map(|index| string[0..index].chars().count() as INT)
.unwrap_or(-1 as INT)
if string.is_empty() {
-1
} else {
string
.find(character)
.map(|index| string[0..index].chars().count() as INT)
.unwrap_or(-1 as INT)
}
}
#[rhai_fn(name = "index_of")]
pub fn index_of_string_starting_from(string: &str, find_string: &str, start: INT) -> INT {
if string.is_empty() {
return -1;
}
let start = if start < 0 {
if let Some(n) = start.checked_abs() {
let chars = string.chars().collect::<Vec<_>>();
@ -251,10 +288,14 @@ mod string_functions {
}
#[rhai_fn(name = "index_of")]
pub fn index_of(string: &str, find_string: &str) -> INT {
string
.find(find_string)
.map(|index| string[0..index].chars().count() as INT)
.unwrap_or(-1 as INT)
if string.is_empty() {
-1
} else {
string
.find(find_string)
.map(|index| string[0..index].chars().count() as INT)
.unwrap_or(-1 as INT)
}
}
pub fn sub_string(
@ -263,6 +304,10 @@ mod string_functions {
start: INT,
len: INT,
) -> ImmutableString {
if string.is_empty() {
return ctx.engine().empty_string.clone();
}
let mut chars = StaticVec::with_capacity(string.len());
let offset = if string.is_empty() || len <= 0 {
@ -308,12 +353,20 @@ mod string_functions {
string: &str,
start: INT,
) -> ImmutableString {
let len = string.len() as INT;
sub_string(ctx, string, start, len)
if string.is_empty() {
ctx.engine().empty_string.clone()
} else {
let len = string.len() as INT;
sub_string(ctx, string, start, len)
}
}
#[rhai_fn(name = "crop")]
pub fn crop(string: &mut ImmutableString, start: INT, len: INT) {
if string.is_empty() {
return;
}
let mut chars = StaticVec::with_capacity(string.len());
let offset = if string.is_empty() || len <= 0 {
@ -358,7 +411,9 @@ mod string_functions {
#[rhai_fn(name = "replace")]
pub fn replace(string: &mut ImmutableString, find_string: &str, substitute_string: &str) {
*string = string.replace(find_string, substitute_string).into();
if !string.is_empty() {
*string = string.replace(find_string, substitute_string).into();
}
}
#[rhai_fn(name = "replace")]
pub fn replace_string_with_char(
@ -366,9 +421,11 @@ mod string_functions {
find_string: &str,
substitute_character: char,
) {
*string = string
.replace(find_string, &substitute_character.to_string())
.into();
if !string.is_empty() {
*string = string
.replace(find_string, &substitute_character.to_string())
.into();
}
}
#[rhai_fn(name = "replace")]
pub fn replace_char_with_string(
@ -376,9 +433,11 @@ mod string_functions {
find_character: char,
substitute_string: &str,
) {
*string = string
.replace(&find_character.to_string(), substitute_string)
.into();
if !string.is_empty() {
*string = string
.replace(&find_character.to_string(), substitute_string)
.into();
}
}
#[rhai_fn(name = "replace")]
pub fn replace_char(
@ -386,12 +445,14 @@ mod string_functions {
find_character: char,
substitute_character: char,
) {
*string = string
.replace(
&find_character.to_string(),
&substitute_character.to_string(),
)
.into();
if !string.is_empty() {
*string = string
.replace(
&find_character.to_string(),
&substitute_character.to_string(),
)
.into();
}
}
#[rhai_fn(return_raw)]
@ -401,6 +462,10 @@ mod string_functions {
len: INT,
character: char,
) -> Result<(), Box<crate::EvalAltResult>> {
if len <= 0 {
return Ok(());
}
let _ctx = ctx;
// Check if string will be over max size limit
@ -413,26 +478,23 @@ mod string_functions {
.into();
}
if len > 0 {
let orig_len = string.chars().count();
let orig_len = string.chars().count();
if len as usize > orig_len {
let p = string.make_mut();
if len as usize > orig_len {
let p = string.make_mut();
for _ in 0..(len as usize - orig_len) {
p.push(character);
}
for _ in 0..(len as usize - orig_len) {
p.push(character);
}
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0
&& string.len() > _ctx.engine().max_string_size()
{
return crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
}
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0 && string.len() > _ctx.engine().max_string_size()
{
return crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
}
}
@ -445,6 +507,10 @@ mod string_functions {
len: INT,
padding: &str,
) -> Result<(), Box<crate::EvalAltResult>> {
if len <= 0 {
return Ok(());
}
let _ctx = ctx;
// Check if string will be over max size limit
@ -457,33 +523,30 @@ mod string_functions {
.into();
}
if len > 0 {
let mut str_len = string.chars().count();
let padding_len = padding.chars().count();
let mut str_len = string.chars().count();
let padding_len = padding.chars().count();
if len as usize > str_len {
let p = string.make_mut();
if len as usize > str_len {
let p = string.make_mut();
while str_len < len as usize {
if str_len + padding_len <= len as usize {
p.push_str(padding);
str_len += padding_len;
} else {
p.extend(padding.chars().take(len as usize - str_len));
str_len = len as usize;
}
while str_len < len as usize {
if str_len + padding_len <= len as usize {
p.push_str(padding);
str_len += padding_len;
} else {
p.extend(padding.chars().take(len as usize - str_len));
str_len = len as usize;
}
}
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0
&& string.len() > _ctx.engine().max_string_size()
{
return crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
}
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0 && string.len() > _ctx.engine().max_string_size()
{
return crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
}
}
@ -496,7 +559,11 @@ mod string_functions {
#[rhai_fn(name = "split")]
pub fn chars(string: &str) -> Array {
string.chars().map(Into::<Dynamic>::into).collect()
if string.is_empty() {
Array::new()
} else {
string.chars().map(Into::<Dynamic>::into).collect()
}
}
#[rhai_fn(name = "split")]
pub fn split_at(ctx: NativeCallContext, string: ImmutableString, start: INT) -> Array {