Add more functions to arrays.

RELEASES.md

@@ -20,6 +20,7 @@ Breaking changes
 * New reserved symbols: `++`, `--`, `..`, `...`.
 * Callback signature for custom syntax implementation function is changed to allow for more flexibility.
 * Default call stack depth for `debug` builds is reduced to 12 (from 16).
+* Precedence for `~` and `%` is raised.
 
 New features
 ------------
@@ -30,7 +31,7 @@ New features
 * `is_def_var()` to detect if variable is defined, and `is_def_fn()` to detect if script function is defined.
 * `Dynamic::from(&str)` now constructs a `Dynamic` with a copy of the string as value.
 * `AST::combine` and `AST::combine_filtered` allows combining two `AST`'s without creating a new one.
-* `map`, `filter` and `reduce` functions for arrays.
+* `map`, `filter`, `reduce`, `reduce_rev`, `some`, `all`, `splice` and `sort` functions for arrays.
 
 Enhancements
 ------------

doc/src/language/arrays.md

@@ -31,7 +31,7 @@ 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<br/>2) element to insert (not another array)                                                                            | inserts an element at the end                                                                                                                                                                                                        |
@@ -46,9 +46,14 @@ The following methods (mostly defined in the [`BasicArrayPackage`][packages] but
 | `pad`                     | 1) target length<br/>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)                                                                                                                                                |
-| `filter`                  | 1) array<br/>2) [function pointer] to predicate (can be a [closure])            | constructs a new array with all items that returns `true` when called with the predicate function:<br/>1st parameter: array item,<br/>2nd parameter: offset index (optional)                                      |
+| `splice`                  | 1) start position (beginning if <= 0, end if >= length),<br/>2) number of items to remove (none if <= 0),<br/>3) array to insert | replaces a portion of the array with another (not necessarily of the same length as the replaced portion)                                                                                                                            |
-| `map`                     | 1) array<br/>2) [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:<br/>1st parameter: array item,<br/>2nd parameter: offset index (optional)                                         |
+| `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:<br/>1st parameter: array item,<br/>2nd parameter: offset index (optional)                                                         |
-| `reduce`                  | 1) array<br/>2) [function pointer] to accumulator function (can be a [closure]) | constructs a new array with all items accumulated by the accumulator function:<br/>1st parameter: accumulated value ([`()`] initially),<br/>2nd parameter: array item,<br/>3rd 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:<br/>1st parameter: array item,<br/>2nd parameter: offset index (optional)                                                            |
+| `reduce`                  | [function pointer] to accumulator function (can be a [closure])                                                                  | constructs a new array with all items accumulated by the accumulator function:<br/>1st parameter: accumulated value ([`()`] initially),<br/>2nd parameter: array item,<br/>3rd parameter: offset index (optional)                    |
+| `reduce_rev`              | [function pointer] to accumulator function (can be a [closure])                                                                  | constructs a new array with all items (in reverse order) accumulated by the accumulator function:<br/>1st parameter: accumulated value ([`()`] initially),<br/>2nd parameter: array item,<br/>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:<br/>1st parameter: array item,<br/>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:<br/>1st parameter: array item,<br/>2nd parameter: offset index (optional)                                                                         |
+| `sort`                    | [function pointer] to a comparison function (can be a [closure])                                                                 | sorts the array with a comparison function:<br/>1st parameter: first item,<br/>2nd parameter: second item                                                                                                                            |
 
 
 Use Custom Types With Arrays
@@ -158,4 +163,29 @@ a.reduce(|sum, v| {
 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 }
+) == 264;
+
+a.reduce_rev(|sum, v, i| {
+    if i == 0 { v } else { sum + v }
+) == 264;
+
+a.some(|v| v > 50) == true;
+
+a.some(|v, i| v < i) == false;
+
+a.all(|v| v > 50) == false;
+
+a.all(|v, i| v > i) == true;
+
+a.splice(1, 1, [1, 3, 2]);
+
+a == [42, 1, 3, 2, 99];
+
+a.sort(|x, y| x -  y);
+
+a == [1, 2, 3, 42, 99];
 ```

src/module/mod.rs

@@ -554,6 +554,7 @@ impl Module {
     #[cfg(not(feature = "no_function"))]
     #[cfg(not(feature = "no_module"))]
     #[inline]
+    #[allow(dead_code)]
     pub(crate) fn set_raw_fn_as_scripted(
         &mut self,
         name: impl Into<String>,

src/packages/array_basic.rs

@@ -13,7 +13,7 @@ use crate::token::Position;
 #[cfg(not(feature = "no_object"))]
 use crate::engine::Map;
 
-use crate::stdlib::{any::TypeId, boxed::Box, string::ToString};
+use crate::stdlib::{any::TypeId, boxed::Box, cmp::Ordering, string::ToString};
 
 pub type Unit = ();
 
@@ -74,6 +74,10 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, {
     lib.set_raw_fn("map", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], map);
     lib.set_raw_fn("filter", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], filter);
     lib.set_raw_fn("reduce", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], reduce);
+    lib.set_raw_fn("reduce_rev", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], reduce_rev);
+    lib.set_raw_fn("some", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], some);
+    lib.set_raw_fn("all", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], all);
+    lib.set_raw_fn("sort", &[TypeId::of::<Array>(), TypeId::of::<FnPtr>()], sort);
 
     // Merge in the module at the end to override `+=` for arrays
     combine_with_exported_module!(lib, "array", array_functions);
@@ -130,6 +134,25 @@ mod array_functions {
     pub fn reverse(list: &mut Array) {
         list.reverse();
     }
+    pub fn splice(list: &mut Array, start: INT, len: INT, replace: Array) {
+        let start = if start < 0 {
+            0
+        } else if start as usize >= list.len() {
+            list.len() - 1
+        } else {
+            start as usize
+        };
+
+        let len = if len < 0 {
+            0
+        } else if len as usize > list.len() - start {
+            list.len() - start
+        } else {
+            len as usize
+        };
+
+        list.splice(start..start + len, replace.into_iter());
+    }
 }
 
 fn pad<T: Variant + Clone>(
@@ -234,6 +257,74 @@ fn filter(
     Ok(array)
 }
 
+fn some(
+    engine: &Engine,
+    lib: &Module,
+    args: &mut [&mut Dynamic],
+) -> Result<bool, Box<EvalAltResult>> {
+    let list = args[0].read_lock::<Array>().unwrap();
+    let filter = args[1].read_lock::<FnPtr>().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(true.into());
+        }
+    }
+
+    Ok(false.into())
+}
+
+fn all(
+    engine: &Engine,
+    lib: &Module,
+    args: &mut [&mut Dynamic],
+) -> Result<bool, Box<EvalAltResult>> {
+    let list = args[0].read_lock::<Array>().unwrap();
+    let filter = args[1].read_lock::<FnPtr>().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,
@@ -268,6 +359,79 @@ fn reduce(
     Ok(result)
 }
 
+fn reduce_rev(
+    engine: &Engine,
+    lib: &Module,
+    args: &mut [&mut Dynamic],
+) -> Result<Dynamic, Box<EvalAltResult>> {
+    let list = args[0].read_lock::<Array>().unwrap();
+    let reducer = args[1].read_lock::<FnPtr>().unwrap();
+
+    let mut result: Dynamic = ().into();
+
+    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,
+    args: &mut [&mut Dynamic],
+) -> Result<Dynamic, Box<EvalAltResult>> {
+    let comparer = args[1].read_lock::<FnPtr>().unwrap().clone();
+    let mut list = args[0].write_lock::<Array>().unwrap();
+
+    list.sort_by(|x, y| {
+        comparer
+            .call_dynamic(engine, lib, None, [x.clone(), y.clone()])
+            .ok()
+            .and_then(|v| v.as_int().ok())
+            .map(|v| {
+                if v > 0 {
+                    Ordering::Greater
+                } else if v < 0 {
+                    Ordering::Less
+                } else {
+                    Ordering::Equal
+                }
+            })
+            .unwrap_or_else(|| {
+                let x_type_id = x.type_id();
+                let y_type_id = y.type_id();
+
+                if x_type_id > y_type_id {
+                    Ordering::Greater
+                } else if x_type_id < y_type_id {
+                    Ordering::Less
+                } else {
+                    Ordering::Equal
+                }
+            })
+    });
+
+    Ok(().into())
+}
+
 gen_array_functions!(basic => INT, bool, char, ImmutableString, FnPtr, Array, Unit);
 
 #[cfg(not(feature = "only_i32"))]

tests/arrays.rs

@@ -168,7 +168,7 @@ fn test_arrays_map_reduce() -> Result<(), Box<EvalAltResult>> {
         engine.eval::<INT>(
             r#"
                 let x = [1, 2, 3];
-                x.reduce(|sum, v| if sum.type_of() == "()" { v } else { sum + v * v })
+                x.reduce(|sum, v| if sum.type_of() == "()" { v * v } else { sum + v * v })
             "#
         )?,
         14
@@ -183,5 +183,54 @@ fn test_arrays_map_reduce() -> Result<(), Box<EvalAltResult>> {
         )?,
         24
     );
+
+    assert_eq!(
+        engine.eval::<INT>(
+            r#"
+                let x = [1, 2, 3];
+                x.reduce_rev(|sum, v| if sum.type_of() == "()" { v * v } else { sum + v * v })
+            "#
+        )?,
+        14
+    );
+
+    assert_eq!(
+        engine.eval::<INT>(
+            r#"
+                let x = [1, 2, 3];
+                x.reduce_rev(|sum, v, i| { if i == 2 { sum = 10 } sum + v * v })
+            "#
+        )?,
+        24
+    );
+
+    assert!(engine.eval::<bool>(
+        r#"
+            let x = [1, 2, 3];
+            x.some(|v| v > 1)
+        "#
+    )?);
+
+    assert!(engine.eval::<bool>(
+        r#"
+            let x = [1, 2, 3];
+            x.some(|v, i| v * i == 0)
+        "#
+    )?);
+
+    assert!(!engine.eval::<bool>(
+        r#"
+            let x = [1, 2, 3];
+            x.all(|v| v > 1)
+        "#
+    )?);
+
+    assert!(engine.eval::<bool>(
+        r#"
+            let x = [1, 2, 3];
+            x.all(|v, i| v > i)
+        "#
+    )?);
+
     Ok(())
 }