Use arrays for multiple geometry (#5770)

* Parse [T] instead of T[] for array types

Signed-off-by: Nick Cameron <nrc@ncameron.org>

* homogenous arrays, type coercion, remove solid set and sketch set, etc

Signed-off-by: Nick Cameron <nrc@ncameron.org>

---------

Signed-off-by: Nick Cameron <nrc@ncameron.org>

rust/kcl-lib/src/std/sweep.rs

@@ -9,7 +9,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     errors::KclError,
-    execution::{ExecState, Helix, KclValue, Sketch, SketchSet, SolidSet},
+    execution::{
+        kcl_value::{ArrayLen, RuntimeType},
+        ExecState, Helix, KclValue, PrimitiveType, Sketch, Solid,
+    },
     std::{extrude::do_post_extrude, fillet::default_tolerance, Args},
 };
 
@@ -24,12 +27,16 @@ pub enum SweepPath {
 
 /// Extrude a sketch along a path.
 pub async fn sweep(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let sketch_set = args.get_unlabeled_kw_arg("sketch_set")?;
+    let sketches = args.get_unlabeled_kw_arg_typed(
+        "sketches",
+        &RuntimeType::Array(PrimitiveType::Sketch, ArrayLen::NonEmpty),
+        exec_state,
+    )?;
     let path: SweepPath = args.get_kw_arg("path")?;
     let sectional = args.get_kw_arg_opt("sectional")?;
     let tolerance = args.get_kw_arg_opt("tolerance")?;
 
-    let value = inner_sweep(sketch_set, path, sectional, tolerance, exec_state, args).await?;
+    let value = inner_sweep(sketches, path, sectional, tolerance, exec_state, args).await?;
     Ok(value.into())
 }
 
@@ -134,26 +141,25 @@ pub async fn sweep(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
     keywords = true,
     unlabeled_first = true,
     args = {
-        sketch_set = { docs = "The sketch or set of sketches that should be swept in space" },
+        sketches = { docs = "The sketch or set of sketches that should be swept in space" },
         path = { docs = "The path to sweep the sketch along" },
         sectional = { docs = "If true, the sweep will be broken up into sub-sweeps (extrusions, revolves, sweeps) based on the trajectory path components." },
         tolerance = { docs = "Tolerance for this operation" },
     }
 }]
 async fn inner_sweep(
-    sketch_set: SketchSet,
+    sketches: Vec<Sketch>,
     path: SweepPath,
     sectional: Option<bool>,
     tolerance: Option<f64>,
     exec_state: &mut ExecState,
     args: Args,
-) -> Result<SolidSet, KclError> {
+) -> Result<Vec<Solid>, KclError> {
     let trajectory = match path {
         SweepPath::Sketch(sketch) => sketch.id.into(),
         SweepPath::Helix(helix) => helix.value.into(),
     };
 
-    let sketches: Vec<Sketch> = sketch_set.into();
     let mut solids = Vec::new();
     for sketch in &sketches {
         let id = exec_state.next_uuid();
@@ -171,5 +177,5 @@ async fn inner_sweep(
         solids.push(do_post_extrude(sketch.clone(), id.into(), 0.0, exec_state, args.clone()).await?);
     }
 
-    Ok(solids.into())
+    Ok(solids)
 }