KCL: Reduce can take and return any KCL values

Previously it only took Array of Number and could only return Sketch.

Now it has been unshackled from the chains of poor type signatures.

src/wasm-lib/kcl/src/docs/gen_std_tests.rs

@@ -787,12 +787,14 @@ fn test_generate_stdlib_json_schema() {
     let stdlib = StdLib::new();
     let combined = stdlib.combined();
 
-    let mut json_data = vec![];
-
-    for key in combined.keys().sorted() {
-        let internal_fn = combined.get(key).unwrap();
-        json_data.push(internal_fn.to_json().unwrap());
-    }
+    let json_data: Vec<_> = combined
+        .keys()
+        .sorted()
+        .map(|key| {
+            let internal_fn = combined.get(key).unwrap();
+            internal_fn.to_json().unwrap()
+        })
+        .collect();
     expectorate::assert_contents(
         "../../../docs/kcl/std.json",
         &serde_json::to_string_pretty(&json_data).unwrap(),

src/wasm-lib/kcl/src/std/array.rs

@@ -4,7 +4,7 @@ use serde_json::Value as JValue;
 use super::{args::FromArgs, Args, FnAsArg};
 use crate::{
     errors::{KclError, KclErrorDetails},
-    executor::{ExecState, KclValue, Sketch, SourceRange, UserVal},
+    executor::{ExecState, KclValue, SourceRange, UserVal},
     function_param::FunctionParam,
 };
 
@@ -98,17 +98,24 @@ async fn call_map_closure<'a>(
 
 /// For each item in an array, update a value.
 pub async fn reduce(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let (array, start, f): (Vec<u64>, Sketch, FnAsArg<'_>) = FromArgs::from_args(&args, 0)?;
+    let (array, start, f): (Vec<JValue>, KclValue, FnAsArg<'_>) = FromArgs::from_args(&args, 0)?;
+    let array: Vec<KclValue> = array
+        .into_iter()
+        .map(|jval| {
+            KclValue::UserVal(UserVal {
+                value: jval,
+                meta: vec![args.source_range.into()],
+            })
+        })
+        .collect();
     let reduce_fn = FunctionParam {
         inner: f.func,
         fn_expr: f.expr,
         meta: vec![args.source_range.into()],
         ctx: args.ctx.clone(),
         memory: *f.memory,
     };
-    inner_reduce(array, start, reduce_fn, exec_state, &args)
-        .await
-        .map(|sg| KclValue::UserVal(UserVal::new(sg.meta.clone(), sg)))
+    inner_reduce(array, start, reduce_fn, exec_state, &args).await
 }
 
 /// Take a starting value. Then, for each element of an array, calculate the next value,
@@ -125,60 +132,47 @@ pub async fn reduce(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// }
 /// decagon(5.0) |> close(%)
 /// ```
+/// ```no_run
+/// array = [1, 2, 3]
+/// sum = reduce(array, 0, (i, result_so_far) => { return i + result_so_far })
+/// assertEqual(sum, 6, 0.00001, "1 + 2 + 3 summed is 6")
+/// ```
 #[stdlib {
     name = "reduce",
 }]
 async fn inner_reduce<'a>(
-    array: Vec<u64>,
-    start: Sketch,
+    array: Vec<KclValue>,
+    start: KclValue,
     reduce_fn: FunctionParam<'a>,
     exec_state: &mut ExecState,
     args: &'a Args,
-) -> Result<Sketch, KclError> {
+) -> Result<KclValue, KclError> {
     let mut reduced = start;
-    for i in array {
-        reduced = call_reduce_closure(i, reduced, &reduce_fn, args.source_range, exec_state).await?;
+    for elem in array {
+        reduced = call_reduce_closure(elem, reduced, &reduce_fn, args.source_range, exec_state).await?;
     }
 
     Ok(reduced)
 }
 
 async fn call_reduce_closure<'a>(
-    i: u64,
-    start: Sketch,
+    elem: KclValue,
+    start: KclValue,
     reduce_fn: &FunctionParam<'a>,
     source_range: SourceRange,
     exec_state: &mut ExecState,
-) -> Result<Sketch, KclError> {
+) -> Result<KclValue, KclError> {
     // Call the reduce fn for this repetition.
-    let reduce_fn_args = vec![
-        KclValue::UserVal(UserVal {
-            value: serde_json::Value::Number(i.into()),
-            meta: vec![source_range.into()],
-        }),
-        KclValue::new_user_val(start.meta.clone(), start),
-    ];
+    let reduce_fn_args = vec![elem, start];
     let transform_fn_return = reduce_fn.call(exec_state, reduce_fn_args).await?;
 
     // Unpack the returned transform object.
     let source_ranges = vec![source_range];
-    let closure_retval = transform_fn_return.ok_or_else(|| {
+    let out = transform_fn_return.ok_or_else(|| {
         KclError::Semantic(KclErrorDetails {
             message: "Reducer function must return a value".to_string(),
             source_ranges: source_ranges.clone(),
         })
     })?;
-    let Some(out) = closure_retval.as_user_val() else {
-        return Err(KclError::Semantic(KclErrorDetails {
-            message: "Reducer function must return a UserValue".to_string(),
-            source_ranges: source_ranges.clone(),
-        }));
-    };
-    let Some((out, _meta)) = out.get() else {
-        return Err(KclError::Semantic(KclErrorDetails {
-            message: "Reducer function must return a Sketch".to_string(),
-            source_ranges: source_ranges.clone(),
-        }));
-    };
     Ok(out)
 }