diff --git a/doc/src/language/arrays.md b/doc/src/language/arrays.md
index ba7e4b7a..7016a19c 100644
--- a/doc/src/language/arrays.md
+++ b/doc/src/language/arrays.md
@@ -30,32 +30,33 @@ Built-in Functions
The following methods (mostly defined in the [`BasicArrayPackage`][packages] but excluded if using a [raw `Engine`]) operate on arrays:
-| Function | Parameter(s) | Description |
-| ------------------------- | --------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `push` | element to insert | inserts an element at the end |
-| `append` | array to append | concatenates the second array to the end of the first |
-| `+=` operator | 1) array
2) element to insert (not another array) | inserts an element at the end |
-| `+=` operator | 1) array
2) array to append | concatenates the second array to the end of the first |
-| `+` operator | 1) first array
2) second array | concatenates the first array with the second |
-| `insert` | 1) element to insert
2) position, beginning if < 0, end if > length | inserts an element at a certain index |
-| `pop` | _none_ | removes the last element and returns it ([`()`] if empty) |
-| `shift` | _none_ | removes the first element and returns it ([`()`] if empty) |
-| `extract` | 1) start position, beginning if < 0, end if > length,
2) number of items to extract, none if < 0 _(optional)_ | extracts a portion of the array into a new array |
-| `remove` | index | removes an element at a particular index and returns it ([`()`] if the index is not valid) |
-| `reverse` | _none_ | reverses the array |
-| `len` method and property | _none_ | returns the number of elements |
-| `pad` | 1) target length
2) element to pad | pads the array with an element to at least a specified length |
-| `clear` | _none_ | empties the array |
-| `truncate` | target length | cuts off the array at exactly a specified length (discarding all subsequent elements) |
-| `chop` | target length | cuts off the head of the array, leaving the tail at exactly a specified length |
-| `splice` | 1) start position, beginning if < 0, end if > length,
2) number of items to remove, none if < 0,
3) array to insert | replaces a portion of the array with another (not necessarily of the same length as the replaced portion) |
-| `filter` | [function pointer] to predicate (can be a [closure]) | constructs a new array with all items that returns `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: offset index _(optional)_ |
-| `map` | [function pointer] to conversion function (can be a [closure]) | constructs a new array with all items mapped to the result of applying the conversion function:
1st parameter: array item,
2nd parameter: offset index _(optional)_ |
-| `reduce` | [function pointer] to accumulator function (can be a [closure]) | reduces the array into a single value via the accumulator function:
1st parameter: accumulated value ([`()`] initially),
2nd parameter: array item,
3rd parameter: offset index _(optional)_ |
-| `reduce_rev` | [function pointer] to accumulator function (can be a [closure]) | reduces the array (in reverse order) into a single value via the accumulator function:
1st parameter: accumulated value ([`()`] initially),
2nd parameter: array item,
3rd parameter: offset index _(optional)_ |
-| `some` | [function pointer] to predicate (can be a [closure]) | returns `true` if any item returns `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: offset index _(optional)_ |
-| `all` | [function pointer] to predicate (can be a [closure]) | returns `true` if all item returns `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: offset index _(optional)_ |
-| `sort` | [function pointer] to a comparison function (can be a [closure]) | sorts the array with a comparison function:
1st parameter: first item,
2nd parameter: second item,
return value: `INT` < 0 if first < second, > 0 if first > second, 0 if first == second |
+| Function | Parameter(s) | Description |
+| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `push` | element to insert | inserts an element at the end |
+| `append` | array to append | concatenates the second array to the end of the first |
+| `+=` operator | 1) array
2) element to insert (not another array) | inserts an element at the end |
+| `+=` operator | 1) array
2) array to append | concatenates the second array to the end of the first |
+| `+` operator | 1) first array
2) second array | concatenates the first array with the second |
+| `insert` | 1) element to insert
2) position, beginning if < 0, end if > length | inserts an element at a certain index |
+| `pop` | _none_ | removes the last element and returns it ([`()`] if empty) |
+| `shift` | _none_ | removes the first element and returns it ([`()`] if empty) |
+| `extract` | 1) start position, beginning if < 0, end if > length,
2) _(optional)_ number of items to extract, none if < 0 | extracts a portion of the array into a new array |
+| `remove` | index | removes an element at a particular index and returns it ([`()`] if the index is not valid) |
+| `reverse` | _none_ | reverses the array |
+| `len` method and property | _none_ | returns the number of elements |
+| `pad` | 1) target length
2) element to pad | pads the array with an element to at least a specified length |
+| `clear` | _none_ | empties the array |
+| `truncate` | target length | cuts off the array at exactly a specified length (discarding all subsequent elements) |
+| `chop` | target length | cuts off the head of the array, leaving the tail at exactly a specified length |
+| `splice` | 1) start position, beginning if < 0, end if > length,
2) number of items to remove, none if < 0,
3) array to insert | replaces a portion of the array with another (not necessarily of the same length as the replaced portion) |
+| `filter` | [function pointer] to predicate (usually a [closure]) | constructs a new array with all items that returns `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: _(optional)_ offset index |
+| `map` | [function pointer] to conversion function (usually a [closure]) | constructs a new array with all items mapped to the result of applying the conversion function:
1st parameter: array item,
2nd parameter: _(optional)_ offset index |
+| `reduce` | 1) [function pointer] to accumulator function (usually a [closure]),
2) _(optional)_ [function pointer] to function (usually a [closure]) that provides the initial value | reduces the array into a single value via the accumulator function:
1st parameter: accumulated value ([`()`] initially),
2nd parameter: array item,
3rd parameter: _(optional)_ offset index |
+| `reduce_rev` | 1) [function pointer] to accumulator function (usually a [closure]),
2) _(optional)_ [function pointer] to function (usually a [closure]) that provides the initial value | reduces the array (in reverse order) into a single value via the accumulator function:
1st parameter: accumulated value ([`()`] initially),
2nd parameter: array item,
3rd parameter: _(optional)_ offset index |
+| `some` | [function pointer] to predicate (usually a [closure]) | returns `true` if any item returns `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: _(optional)_ offset index |
+| `none` | [function pointer] to predicate (usually a [closure]) | returns `true` if no item returns `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: _(optional)_ offset index |
+| `all` | [function pointer] to predicate (usually a [closure]) | returns `true` if all items return `true` when called with the predicate function:
1st parameter: array item,
2nd parameter: _(optional)_ offset index |
+| `sort` | [function pointer] to a comparison function (usually a [closure]) | sorts the array with a comparison function:
1st parameter: first item,
2nd parameter: second item,
return value: `INT` < 0 if first < second, > 0 if first > second, 0 if first == second |
Use Custom Types With Arrays
@@ -156,21 +157,29 @@ a.filter(|v| v > 50); // returns [123, 99]
a.filter(|v, i| i == 1); // returns [123]
-a.reduce(|sum, v| {
- // Detect the initial value of '()'
- if sum.type_of() == "()" { v } else { sum + v }
+// Use a closure to provide the initial value
+a.reduce(|sum, v| sum + v, || 0) == 264;
+
+// Detect the initial value of '()'
+a.reduce(
+ |sum, v| if sum.type_of() == "()" { v } else { sum + v }
) == 264;
-a.reduce(|sum, v, i| {
+// Detect the initial value via index
+a.reduce(|sum, v, i|
if i == 0 { v } else { sum + v }
) == 264;
-a.reduce_rev(|sum, v| {
- // Detect the initial value of '()'
- if sum.type_of() == "()" { v } else { sum + v }
+// Use a closure to provide the initial value
+a.reduce_rev(|sum, v| sum + v, || 0) == 264;
+
+// Detect the initial value of '()'
+a.reduce_rev(
+ |sum, v| if sum.type_of() == "()" { v } else { sum + v }
) == 264;
-a.reduce_rev(|sum, v, i| {
+// Detect the initial value via index
+a.reduce_rev(|sum, v, i|
if i == 2 { v } else { sum + v }
) == 264;
@@ -178,6 +187,10 @@ a.some(|v| v > 50); // returns true
a.some(|v, i| v < i); // returns false
+a.none(|v| v != 0); // returns false
+
+a.none(|v, i| v == i); // returns true
+
a.all(|v| v > 50); // returns false
a.all(|v, i| v > i); // returns true
@@ -186,5 +199,5 @@ a.splice(1, 1, [1, 3, 2]); // a == [42, 1, 3, 2, 99]
a.extract(1, 3); // returns [1, 3, 2]
-a.sort(|x, y| x - y); // a == [1, 2, 3, 42, 99]
+a.sort(|x, y| x - y); // a == [1, 2, 3, 42, 99]
```
diff --git a/doc/src/language/string-fn.md b/doc/src/language/string-fn.md
index d6e373a5..00efd8e1 100644
--- a/doc/src/language/string-fn.md
+++ b/doc/src/language/string-fn.md
@@ -6,20 +6,20 @@ Built-in String Functions
The following standard methods (mostly defined in the [`MoreStringPackage`][packages] but excluded if
using a [raw `Engine`]) operate on [strings]:
-| Function | Parameter(s) | Description |
-| ------------------------- | --------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| `len` method and property | _none_ | returns the number of characters (not number of bytes) in the string |
-| `pad` | 1) character to pad
2) target length | pads the string with an character to at least a specified length |
-| `+=` operator, `append` | character/string to append | Adds a character or a string to the end of another string |
-| `clear` | _none_ | empties the string |
-| `truncate` | target length | cuts off the string at exactly a specified number of characters |
-| `contains` | character/sub-string to search for | checks if a certain character or sub-string occurs in the string |
-| `index_of` | 1) character/sub-string to search for
2) start index _(optional)_ | returns the index that a certain character or sub-string occurs in the string, or -1 if not found |
-| `sub_string` | 1) start index
2) length _(optional)_ | extracts a sub-string (to the end of the string if length is not specified) |
-| `split` | delimiter character/string | splits the string by the specified delimiter, returning an [array] of string segments; not available under [`no_index`] |
-| `crop` | 1) start index
2) length _(optional)_ | retains only a portion of the string (to the end of the string if length is not specified) |
-| `replace` | 1) target character/sub-string
2) replacement character/string | replaces a sub-string with another |
-| `trim` | _none_ | trims the string of whitespace at the beginning and end |
+| Function | Parameter(s) | Description |
+| ------------------------- | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `len` method and property | _none_ | returns the number of characters (not number of bytes) in the string |
+| `pad` | 1) character to pad
2) target length | pads the string with an character to at least a specified length |
+| `+=` operator, `append` | character/string to append | Adds a character or a string to the end of another string |
+| `clear` | _none_ | empties the string |
+| `truncate` | target length | cuts off the string at exactly a specified number of characters |
+| `contains` | character/sub-string to search for | checks if a certain character or sub-string occurs in the string |
+| `index_of` | 1) character/sub-string to search for
2) _(optional)_ start index | returns the index that a certain character or sub-string occurs in the string, or -1 if not found |
+| `sub_string` | 1) start index
2) _(optional)_ number of characters to extract, none if < 0 | extracts a sub-string (to the end of the string if length is not specified) |
+| `split` | delimiter character/string | splits the string by the specified delimiter, returning an [array] of string segments; not available under [`no_index`] |
+| `crop` | 1) start index
2) _(optional)_ number of characters to retain, none if < 0 | retains only a portion of the string |
+| `replace` | 1) target character/sub-string
2) replacement character/string | replaces a sub-string with another |
+| `trim` | _none_ | trims the string of whitespace at the beginning and end |
Examples
--------
diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs
index 117bf2c8..d688ef3a 100644
--- a/src/packages/array_basic.rs
+++ b/src/packages/array_basic.rs
@@ -74,9 +74,12 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, {
lib.set_raw_fn("map", &[TypeId::of::(), TypeId::of::()], map);
lib.set_raw_fn("filter", &[TypeId::of::(), TypeId::of::()], filter);
lib.set_raw_fn("reduce", &[TypeId::of::(), TypeId::of::()], reduce);
+ lib.set_raw_fn("reduce", &[TypeId::of::(), TypeId::of::(), TypeId::of::()], reduce_with_initial);
lib.set_raw_fn("reduce_rev", &[TypeId::of::(), TypeId::of::()], reduce_rev);
+ lib.set_raw_fn("reduce_rev", &[TypeId::of::(), TypeId::of::(), TypeId::of::()], reduce_rev_with_initial);
lib.set_raw_fn("some", &[TypeId::of::(), TypeId::of::()], some);
lib.set_raw_fn("all", &[TypeId::of::(), TypeId::of::()], all);
+ lib.set_raw_fn("none", &[TypeId::of::(), TypeId::of::()], none);
lib.set_raw_fn("sort", &[TypeId::of::(), TypeId::of::()], sort);
// Merge in the module at the end to override `+=` for arrays
@@ -364,6 +367,40 @@ fn all(
Ok(true.into())
}
+fn none(
+ engine: &Engine,
+ lib: &Module,
+ args: &mut [&mut Dynamic],
+) -> Result> {
+ let list = args[0].read_lock::().unwrap();
+ let filter = args[1].read_lock::().unwrap();
+
+ for (i, item) in list.iter().enumerate() {
+ if filter
+ .call_dynamic(engine, lib, None, [item.clone()])
+ .or_else(|err| match *err {
+ EvalAltResult::ErrorFunctionNotFound(_, _) => {
+ filter.call_dynamic(engine, lib, None, [item.clone(), (i as INT).into()])
+ }
+ _ => Err(err),
+ })
+ .map_err(|err| {
+ Box::new(EvalAltResult::ErrorInFunctionCall(
+ "filter".to_string(),
+ err,
+ Position::none(),
+ ))
+ })?
+ .as_bool()
+ .unwrap_or(false)
+ {
+ return Ok(false.into());
+ }
+ }
+
+ Ok(true.into())
+}
+
fn reduce(
engine: &Engine,
lib: &Module,
@@ -398,6 +435,47 @@ fn reduce(
Ok(result)
}
+fn reduce_with_initial(
+ engine: &Engine,
+ lib: &Module,
+ args: &mut [&mut Dynamic],
+) -> Result> {
+ let list = args[0].read_lock::().unwrap();
+ let reducer = args[1].read_lock::().unwrap();
+ let initial = args[2].read_lock::().unwrap();
+
+ let mut result = initial.call_dynamic(engine, lib, None, []).map_err(|err| {
+ Box::new(EvalAltResult::ErrorInFunctionCall(
+ "reduce".to_string(),
+ err,
+ Position::none(),
+ ))
+ })?;
+
+ for (i, item) in list.iter().enumerate() {
+ result = reducer
+ .call_dynamic(engine, lib, None, [result.clone(), item.clone()])
+ .or_else(|err| match *err {
+ EvalAltResult::ErrorFunctionNotFound(_, _) => reducer.call_dynamic(
+ engine,
+ lib,
+ None,
+ [result, item.clone(), (i as INT).into()],
+ ),
+ _ => Err(err),
+ })
+ .map_err(|err| {
+ Box::new(EvalAltResult::ErrorInFunctionCall(
+ "reduce".to_string(),
+ err,
+ Position::none(),
+ ))
+ })?;
+ }
+
+ Ok(result)
+}
+
fn reduce_rev(
engine: &Engine,
lib: &Module,
@@ -432,6 +510,47 @@ fn reduce_rev(
Ok(result)
}
+fn reduce_rev_with_initial(
+ engine: &Engine,
+ lib: &Module,
+ args: &mut [&mut Dynamic],
+) -> Result> {
+ let list = args[0].read_lock::().unwrap();
+ let reducer = args[1].read_lock::().unwrap();
+ let initial = args[2].read_lock::().unwrap();
+
+ let mut result = initial.call_dynamic(engine, lib, None, []).map_err(|err| {
+ Box::new(EvalAltResult::ErrorInFunctionCall(
+ "reduce".to_string(),
+ err,
+ Position::none(),
+ ))
+ })?;
+
+ for (i, item) in list.iter().enumerate().rev() {
+ result = reducer
+ .call_dynamic(engine, lib, None, [result.clone(), item.clone()])
+ .or_else(|err| match *err {
+ EvalAltResult::ErrorFunctionNotFound(_, _) => reducer.call_dynamic(
+ engine,
+ lib,
+ None,
+ [result, item.clone(), (i as INT).into()],
+ ),
+ _ => Err(err),
+ })
+ .map_err(|err| {
+ Box::new(EvalAltResult::ErrorInFunctionCall(
+ "reduce".to_string(),
+ err,
+ Position::none(),
+ ))
+ })?;
+ }
+
+ Ok(result)
+}
+
fn sort(
engine: &Engine,
lib: &Module,