push, reduce, and map with kw args

docs/kcl/push.md

@@ -17,8 +17,8 @@ push(array: [KclValue], elem: KclValue) -> KclValue
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `array` | [`[KclValue]`](/docs/kcl/types/KclValue) |  | Yes |
-| `elem` | [`KclValue`](/docs/kcl/types/KclValue) | Any KCL value. | Yes |
+| `array` | [`[KclValue]`](/docs/kcl/types/KclValue) | The array to push to. | Yes |
+| `elem` | [`KclValue`](/docs/kcl/types/KclValue) | The element to push to the array. | Yes |
 
 ### Returns
 
@@ -29,7 +29,7 @@ push(array: [KclValue], elem: KclValue) -> KclValue
 
 ```js
 arr = [1, 2, 3]
-new_arr = push(arr, 4)
+new_arr = push(arr, elem = 4)
 assertEqual(new_arr[3], 4, 0.00001, "4 was added to the end of the array")
 ```
 

docs/kcl/reduce.md

@@ -17,9 +17,9 @@ reduce(array: [KclValue], start: KclValue, reduce_fn: FunctionParam) -> KclValue
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `array` | [`[KclValue]`](/docs/kcl/types/KclValue) |  | Yes |
-| `start` | [`KclValue`](/docs/kcl/types/KclValue) | Any KCL value. | Yes |
-| `reduce_fn` | `FunctionParam` |  | Yes |
+| `array` | [`[KclValue]`](/docs/kcl/types/KclValue) | The array to reduce. | Yes |
+| `start` | [`KclValue`](/docs/kcl/types/KclValue) | The starting value for the reduction. | Yes |
+| `reduce_fn` | `FunctionParam` | The function to reduce the array with. | Yes |
 
 ### Returns
 
@@ -38,7 +38,7 @@ fn add(a, b) {
 // It uses the `reduce` function, to call the `add` function on every
 // element of the `arr` parameter. The starting value is 0.
 fn sum(arr) {
-  return reduce(arr, 0, add)
+  return reduce(arr, start = 0, reduce_fn = add)
 }
 
 /* The above is basically like this pseudo-code:
@@ -61,7 +61,7 @@ assertEqual(sum([1, 2, 3]), 6, 0.00001, "1 + 2 + 3 summed is 6")
 // an anonymous `add` function as its parameter, instead of declaring a
 // named function outside.
 arr = [1, 2, 3]
-sum = reduce(arr, 0, fn(i, result_so_far) {
+sum = reduce(arr, start = 0, reduce_fn = fn(i, result_so_far) {
   return i + result_so_far
 })
 
@@ -85,7 +85,7 @@ fn decagon(radius) {
     // Use a `reduce` to draw the remaining decagon sides.
     // For each number in the array 1..10, run the given function,
   // which takes a partially-sketched decagon and adds one more edge to it.
-  fullDecagon = reduce([1..10], startOfDecagonSketch, fn(i, partialDecagon) {
+  fullDecagon = reduce([1..10], start = startOfDecagonSketch, reduce_fn = fn(i, partialDecagon) {
     // Draw one edge of the decagon.
     x = cos(stepAngle * i) * radius
     y = sin(stepAngle * i) * radius

docs/kcl/std.json

@@ -106563,7 +106563,7 @@
     "summary": "Apply a function to every element of a list.",
     "description": "Given a list like `[a, b, c]`, and a function like `f`, returns `[f(a), f(b), f(c)]`",
     "tags": [],
-    "keywordArguments": false,
+    "keywordArguments": true,
     "args": [
       {
         "name": "array",
@@ -108641,7 +108641,8 @@
           }
         },
         "required": true,
-        "labelRequired": true
+        "description": "The array to map.",
+        "labelRequired": false
       },
       {
         "name": "map_fn",
@@ -110716,6 +110717,7 @@
           }
         },
         "required": true,
+        "description": "The function to map the array with.",
         "labelRequired": true
       }
     ],
@@ -112800,8 +112802,8 @@
     "unpublished": false,
     "deprecated": false,
     "examples": [
-      "r = 10 // radius\nfn drawCircle(id) {\n  return startSketchOn(\"XY\")\n    |> circle({ center = [id * 2 * r, 0], radius = r }, %)\n}\n\n// Call `drawCircle`, passing in each element of the array.\n// The outputs from each `drawCircle` form a new array,\n// which is the return value from `map`.\ncircles = map([1..3], drawCircle)",
-      "r = 10 // radius\n// Call `map`, using an anonymous function instead of a named one.\ncircles = map([1..3], fn(id) {\n  return startSketchOn(\"XY\")\n    |> circle({ center = [id * 2 * r, 0], radius = r }, %)\n})"
+      "r = 10 // radius\nfn drawCircle(id) {\n  return startSketchOn(\"XY\")\n    |> circle({ center = [id * 2 * r, 0], radius = r }, %)\n}\n\n// Call `drawCircle`, passing in each element of the array.\n// The outputs from each `drawCircle` form a new array,\n// which is the return value from `map`.\ncircles = map([1..3], map_fn = drawCircle)",
+      "r = 10 // radius\n// Call `map`, using an anonymous function instead of a named one.\ncircles = map([1..3], map_fn = fn(id) {\n  return startSketchOn(\"XY\")\n    |> circle({ center = [id * 2 * r, 0], radius = r }, %)\n})"
     ]
   },
   {
@@ -146967,7 +146969,7 @@
     "summary": "Append an element to the end of an array.",
     "description": "Returns a new array with the element appended.",
     "tags": [],
-    "keywordArguments": false,
+    "keywordArguments": true,
     "args": [
       {
         "name": "array",
@@ -149045,7 +149047,8 @@
           }
         },
         "required": true,
-        "labelRequired": true
+        "description": "The array to push to.",
+        "labelRequired": false
       },
       {
         "name": "elem",
@@ -151802,6 +151805,7 @@
           }
         },
         "required": true,
+        "description": "The element to push to the array.",
         "labelRequired": true
       }
     ],
@@ -154565,7 +154569,7 @@
     "unpublished": false,
     "deprecated": false,
     "examples": [
-      "arr = [1, 2, 3]\nnew_arr = push(arr, 4)\nassertEqual(new_arr[3], 4, 0.00001, \"4 was added to the end of the array\")"
+      "arr = [1, 2, 3]\nnew_arr = push(arr, elem = 4)\nassertEqual(new_arr[3], 4, 0.00001, \"4 was added to the end of the array\")"
     ]
   },
   {
@@ -154573,7 +154577,7 @@
     "summary": "Take a starting value. Then, for each element of an array, calculate the next value,",
     "description": "using the previous value and the element.",
     "tags": [],
-    "keywordArguments": false,
+    "keywordArguments": true,
     "args": [
       {
         "name": "array",
@@ -156651,7 +156655,8 @@
           }
         },
         "required": true,
-        "labelRequired": true
+        "description": "The array to reduce.",
+        "labelRequired": false
       },
       {
         "name": "start",
@@ -159408,6 +159413,7 @@
           }
         },
         "required": true,
+        "description": "The starting value for the reduction.",
         "labelRequired": true
       },
       {
@@ -161483,6 +161489,7 @@
           }
         },
         "required": true,
+        "description": "The function to reduce the array with.",
         "labelRequired": true
       }
     ],
@@ -164246,9 +164253,9 @@
     "unpublished": false,
     "deprecated": false,
     "examples": [
-      "// This function adds two numbers.\nfn add(a, b) {\n  return a + b\n}\n\n// This function adds an array of numbers.\n// It uses the `reduce` function, to call the `add` function on every\n// element of the `arr` parameter. The starting value is 0.\nfn sum(arr) {\n  return reduce(arr, 0, add)\n}\n\n/* The above is basically like this pseudo-code:\nfn sum(arr):\n    sumSoFar = 0\n    for i in arr:\n        sumSoFar = add(sumSoFar, i)\n    return sumSoFar */\n\n\n// We use `assertEqual` to check that our `sum` function gives the\n// expected result. It's good to check your work!\nassertEqual(sum([1, 2, 3]), 6, 0.00001, \"1 + 2 + 3 summed is 6\")",
-      "// This example works just like the previous example above, but it uses\n// an anonymous `add` function as its parameter, instead of declaring a\n// named function outside.\narr = [1, 2, 3]\nsum = reduce(arr, 0, fn(i, result_so_far) {\n  return i + result_so_far\n})\n\n// We use `assertEqual` to check that our `sum` function gives the\n// expected result. It's good to check your work!\nassertEqual(sum, 6, 0.00001, \"1 + 2 + 3 summed is 6\")",
-      "// Declare a function that sketches a decagon.\nfn decagon(radius) {\n  // Each side of the decagon is turned this many degrees from the previous angle.\n  stepAngle = 1 / 10 * tau()\n\n  // Start the decagon sketch at this point.\n  startOfDecagonSketch = startSketchOn('XY')\n    |> startProfileAt([cos(0) * radius, sin(0) * radius], %)\n\n    // Use a `reduce` to draw the remaining decagon sides.\n    // For each number in the array 1..10, run the given function,\n  // which takes a partially-sketched decagon and adds one more edge to it.\n  fullDecagon = reduce([1..10], startOfDecagonSketch, fn(i, partialDecagon) {\n    // Draw one edge of the decagon.\n    x = cos(stepAngle * i) * radius\n    y = sin(stepAngle * i) * radius\n    return lineTo([x, y], partialDecagon)\n  })\n\n  return fullDecagon\n}\n\n/* The `decagon` above is basically like this pseudo-code:\nfn decagon(radius):\n    stepAngle = (1/10) * tau()\n    plane = startSketchOn('XY')\n    startOfDecagonSketch = startProfileAt([(cos(0)*radius), (sin(0) * radius)], plane)\n\n    // Here's the reduce part.\n    partialDecagon = startOfDecagonSketch\n    for i in [1..10]:\n        x = cos(stepAngle * i) * radius\n        y = sin(stepAngle * i) * radius\n        partialDecagon = lineTo([x, y], partialDecagon)\n    fullDecagon = partialDecagon // it's now full\n    return fullDecagon */\n\n\n// Use the `decagon` function declared above, to sketch a decagon with radius 5.\ndecagon(5.0)\n  |> close(%)"
+      "// This function adds two numbers.\nfn add(a, b) {\n  return a + b\n}\n\n// This function adds an array of numbers.\n// It uses the `reduce` function, to call the `add` function on every\n// element of the `arr` parameter. The starting value is 0.\nfn sum(arr) {\n  return reduce(arr, start = 0, reduce_fn = add)\n}\n\n/* The above is basically like this pseudo-code:\nfn sum(arr):\n    sumSoFar = 0\n    for i in arr:\n        sumSoFar = add(sumSoFar, i)\n    return sumSoFar */\n\n\n// We use `assertEqual` to check that our `sum` function gives the\n// expected result. It's good to check your work!\nassertEqual(sum([1, 2, 3]), 6, 0.00001, \"1 + 2 + 3 summed is 6\")",
+      "// This example works just like the previous example above, but it uses\n// an anonymous `add` function as its parameter, instead of declaring a\n// named function outside.\narr = [1, 2, 3]\nsum = reduce(arr, start = 0, reduce_fn = fn(i, result_so_far) {\n  return i + result_so_far\n})\n\n// We use `assertEqual` to check that our `sum` function gives the\n// expected result. It's good to check your work!\nassertEqual(sum, 6, 0.00001, \"1 + 2 + 3 summed is 6\")",
+      "// Declare a function that sketches a decagon.\nfn decagon(radius) {\n  // Each side of the decagon is turned this many degrees from the previous angle.\n  stepAngle = 1 / 10 * tau()\n\n  // Start the decagon sketch at this point.\n  startOfDecagonSketch = startSketchOn('XY')\n    |> startProfileAt([cos(0) * radius, sin(0) * radius], %)\n\n    // Use a `reduce` to draw the remaining decagon sides.\n    // For each number in the array 1..10, run the given function,\n  // which takes a partially-sketched decagon and adds one more edge to it.\n  fullDecagon = reduce([1..10], start = startOfDecagonSketch, reduce_fn = fn(i, partialDecagon) {\n    // Draw one edge of the decagon.\n    x = cos(stepAngle * i) * radius\n    y = sin(stepAngle * i) * radius\n    return lineTo([x, y], partialDecagon)\n  })\n\n  return fullDecagon\n}\n\n/* The `decagon` above is basically like this pseudo-code:\nfn decagon(radius):\n    stepAngle = (1/10) * tau()\n    plane = startSketchOn('XY')\n    startOfDecagonSketch = startProfileAt([(cos(0)*radius), (sin(0) * radius)], plane)\n\n    // Here's the reduce part.\n    partialDecagon = startOfDecagonSketch\n    for i in [1..10]:\n        x = cos(stepAngle * i) * radius\n        y = sin(stepAngle * i) * radius\n        partialDecagon = lineTo([x, y], partialDecagon)\n    fullDecagon = partialDecagon // it's now full\n    return fullDecagon */\n\n\n// Use the `decagon` function declared above, to sketch a decagon with radius 5.\ndecagon(5.0)\n  |> close(%)"
     ]
   },
   {

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

@@ -1,9 +1,6 @@
 use derive_docs::stdlib;
 
-use super::{
-    args::{Arg, FromArgs},
-    Args, FnAsArg,
-};
+use super::{args::Arg, Args, FnAsArg};
 use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{ExecState, FunctionParam, KclValue},
@@ -12,14 +9,47 @@ use crate::{
 
 /// Apply a function to each element of an array.
 pub async fn map(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
-    let (array, f): (Vec<KclValue>, FnAsArg<'_>) = FromArgs::from_args(&args, 0)?;
+    let array = args.get_unlabeled_kw_arg("array")?;
+
+    // Check that the array is an array
+    let array: Vec<KclValue> = match array {
+        KclValue::Array { value, meta: _ } => value,
+        _ => {
+            return Err(KclError::Semantic(KclErrorDetails {
+                source_ranges: vec![args.source_range],
+                message: format!(
+                    "Expected an array to map, but got a value of type {}",
+                    array.human_friendly_type()
+                ),
+            }))
+        }
+    };
+
+    // Check that the map_fn is a function
+    let map_fn_kclvalue: KclValue = args.get_kw_arg("map_fn")?;
+    match map_fn_kclvalue {
+        KclValue::Function { .. } => (),
+        _ => {
+            return Err(KclError::Semantic(KclErrorDetails {
+                source_ranges: vec![args.source_range],
+                message: format!(
+                    "Expected map_fn to be a function, but got a value of type {}",
+                    map_fn_kclvalue.human_friendly_type()
+                ),
+            }))
+        }
+    }
+
+    // Extract the function from the KclValue
+    let map_fn: FnAsArg<'_> = args.get_kw_arg("map_fn")?;
+
     let meta = vec![args.source_range.into()];
     let map_fn = FunctionParam {
-        inner: f.func,
-        fn_expr: f.expr,
+        inner: map_fn.func,
+        fn_expr: map_fn.expr,
         meta: meta.clone(),
         ctx: args.ctx.clone(),
-        memory: *f.memory,
+        memory: *map_fn.memory,
     };
     let new_array = inner_map(array, map_fn, exec_state, &args).await?;
     Ok(KclValue::Array { value: new_array, meta })
@@ -41,7 +71,7 @@ pub async fn map(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kcl
 /// // which is the return value from `map`.
 /// circles = map(
 ///   [1..3],
-///   drawCircle
+///   map_fn = drawCircle
 /// )
 /// ```
 /// ```no_run
@@ -49,7 +79,7 @@ pub async fn map(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kcl
 /// // Call `map`, using an anonymous function instead of a named one.
 /// circles = map(
 ///   [1..3],
-///   fn(id) {
+///   map_fn = fn(id) {
 ///     return startSketchOn("XY")
 ///       |> circle({ center: [id * 2 * r, 0], radius: r}, %)
 ///   }
@@ -57,6 +87,12 @@ pub async fn map(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kcl
 /// ```
 #[stdlib {
     name = "map",
+    keywords = true,
+    unlabeled_first = true,
+    arg_docs = {
+        array = "The array to map.",
+        map_fn = "The function to map the array with.",
+    }
 }]
 async fn inner_map<'a>(
     array: Vec<KclValue>,
@@ -91,13 +127,43 @@ 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<KclValue>, KclValue, FnAsArg<'_>) = FromArgs::from_args(&args, 0)?;
+    let array_val = args.get_unlabeled_kw_arg("array")?;
+    let start = args.get_kw_arg("start")?;
+    let reduce_fn_kclvalue: KclValue = args.get_kw_arg("reduce_fn")?;
+
+    let array: Vec<KclValue> = match array_val {
+        KclValue::Array { value, meta: _ } => value,
+        _ => {
+            return Err(KclError::Semantic(KclErrorDetails {
+                source_ranges: vec![args.source_range],
+                message: format!("You can't reduce a value of type {}", array_val.human_friendly_type()),
+            }))
+        }
+    };
+
+    // Check that the reduce_fn is a function
+    match reduce_fn_kclvalue {
+        KclValue::Function { .. } => (),
+        _ => {
+            return Err(KclError::Semantic(KclErrorDetails {
+                source_ranges: vec![args.source_range],
+                message: format!(
+                    "Expected reduce_fn to be a function, but got a value of type {}",
+                    reduce_fn_kclvalue.human_friendly_type()
+                ),
+            }))
+        }
+    }
+
+    // Extract the function from the KclValue
+    let reduce_fn: FnAsArg<'_> = args.get_kw_arg("reduce_fn")?;
+
     let reduce_fn = FunctionParam {
-        inner: f.func,
-        fn_expr: f.expr,
+        inner: reduce_fn.func,
+        fn_expr: reduce_fn.expr,
         meta: vec![args.source_range.into()],
         ctx: args.ctx.clone(),
-        memory: *f.memory,
+        memory: *reduce_fn.memory,
     };
     inner_reduce(array, start, reduce_fn, exec_state, &args).await
 }
@@ -111,7 +177,7 @@ pub async fn reduce(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// // This function adds an array of numbers.
 /// // It uses the `reduce` function, to call the `add` function on every
 /// // element of the `arr` parameter. The starting value is 0.
-/// fn sum(arr) { return reduce(arr, 0, add) }
+/// fn sum(arr) { return reduce(arr, start = 0, reduce_fn = add) }
 ///
 /// /*
 /// The above is basically like this pseudo-code:
@@ -131,7 +197,7 @@ pub async fn reduce(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// // an anonymous `add` function as its parameter, instead of declaring a
 /// // named function outside.
 /// arr = [1, 2, 3]
-/// sum = reduce(arr, 0, (i, result_so_far) => { return i + result_so_far })
+/// sum = reduce(arr, start = 0, reduce_fn = (i, result_so_far) => { return i + result_so_far })
 ///
 /// // We use `assertEqual` to check that our `sum` function gives the
 /// // expected result. It's good to check your work!
@@ -150,7 +216,7 @@ pub async fn reduce(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 ///   // Use a `reduce` to draw the remaining decagon sides.
 ///   // For each number in the array 1..10, run the given function,
 ///   // which takes a partially-sketched decagon and adds one more edge to it.
-///   fullDecagon = reduce([1..10], startOfDecagonSketch, fn(i, partialDecagon) {
+///   fullDecagon = reduce([1..10], start = startOfDecagonSketch, reduce_fn = fn(i, partialDecagon) {
 ///       // Draw one edge of the decagon.
 ///       x = cos(stepAngle * i) * radius
 ///       y = sin(stepAngle * i) * radius
@@ -183,6 +249,13 @@ pub async fn reduce(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// ```
 #[stdlib {
     name = "reduce",
+    keywords = true,
+    unlabeled_first = true,
+    arg_docs = {
+        array = "The array to reduce.",
+        start = "The starting value for the reduction.",
+        reduce_fn = "The function to reduce the array with.",
+    }
 }]
 async fn inner_reduce<'a>(
     array: Vec<KclValue>,
@@ -227,11 +300,17 @@ async fn call_reduce_closure<'a>(
 ///
 /// ```no_run
 /// arr = [1, 2, 3]
-/// new_arr = push(arr, 4)
+/// new_arr = push(arr, elem = 4)
 /// assertEqual(new_arr[3], 4, 0.00001, "4 was added to the end of the array")
 /// ```
 #[stdlib {
     name = "push",
+    keywords = true,
+    unlabeled_first = true,
+    arg_docs = {
+        array = "The array to push to.",
+        elem = "The element to push to the array.",
+    }
 }]
 async fn inner_push(mut array: Vec<KclValue>, elem: KclValue, args: &Args) -> Result<KclValue, KclError> {
     // Unwrap the KclValues to JValues for manipulation
@@ -244,7 +323,8 @@ async fn inner_push(mut array: Vec<KclValue>, elem: KclValue, args: &Args) -> Re
 
 pub async fn push(_exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
     // Extract the array and the element from the arguments
-    let (val, elem): (KclValue, KclValue) = FromArgs::from_args(&args, 0)?;
+    let val = args.get_unlabeled_kw_arg("array")?;
+    let elem = args.get_kw_arg("elem")?;
 
     let meta = vec![args.source_range];
     let KclValue::Array { value: array, meta: _ } = val else {

src/wasm-lib/kcl/tests/argument_error/ast.snap

@@ -1,6 +1,8 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 55
 description: Result of parsing argument_error.kcl
+snapshot_kind: text
 ---
 {
   "Ok": {
@@ -61,39 +63,39 @@ description: Result of parsing argument_error.kcl
         "type": "VariableDeclaration"
       },
       {
-        "end": 38,
+        "end": 47,
         "expression": {
           "arguments": [
             {
-              "end": 29,
-              "name": "f",
-              "start": 28,
-              "type": "Identifier",
-              "type": "Identifier"
-            },
-            {
-              "elements": [
-                {
-                  "end": 33,
-                  "raw": "0",
-                  "start": 32,
-                  "type": "Literal",
-                  "type": "Literal",
-                  "value": 0.0
-                },
-                {
-                  "end": 36,
-                  "raw": "1",
-                  "start": 35,
-                  "type": "Literal",
-                  "type": "Literal",
-                  "value": 1.0
-                }
-              ],
-              "end": 37,
-              "start": 31,
-              "type": "ArrayExpression",
-              "type": "ArrayExpression"
+              "type": "LabeledArg",
+              "label": {
+                "type": "Identifier",
+                "name": "map_fn"
+              },
+              "arg": {
+                "elements": [
+                  {
+                    "end": 42,
+                    "raw": "0",
+                    "start": 41,
+                    "type": "Literal",
+                    "type": "Literal",
+                    "value": 0.0
+                  },
+                  {
+                    "end": 45,
+                    "raw": "1",
+                    "start": 44,
+                    "type": "Literal",
+                    "type": "Literal",
+                    "value": 1.0
+                  }
+                ],
+                "end": 46,
+                "start": 40,
+                "type": "ArrayExpression",
+                "type": "ArrayExpression"
+              }
             }
           ],
           "callee": {
@@ -102,17 +104,24 @@ description: Result of parsing argument_error.kcl
             "start": 24,
             "type": "Identifier"
           },
-          "end": 38,
+          "end": 47,
           "start": 24,
-          "type": "CallExpression",
-          "type": "CallExpression"
+          "type": "CallExpressionKw",
+          "type": "CallExpressionKw",
+          "unlabeled": {
+            "end": 29,
+            "name": "f",
+            "start": 28,
+            "type": "Identifier",
+            "type": "Identifier"
+          }
         },
         "start": 24,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       }
     ],
-    "end": 39,
+    "end": 48,
     "nonCodeMeta": {
       "nonCodeNodes": {
         "0": [

src/wasm-lib/kcl/tests/argument_error/execution_error.snap

@@ -1,12 +1,14 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 133
 description: Error from executing argument_error.kcl
+snapshot_kind: text
 ---
-KCL Type error
+KCL Semantic error
 
-  × type: Expected an array but found Function
-   ╭─[5:5]
+  × semantic: Expected an array to map, but got a value of type Function
+   ╭─[5:1]
  4 │ 
- 5 │ map(f, [0, 1])
-   ·     ─
+ 5 │ map(f, map_fn = [0, 1])
+   · ───────────────────────
    ╰────

src/wasm-lib/kcl/tests/argument_error/input.kcl

@@ -2,4 +2,4 @@ fn f(i) {
   return 5
 }
 
-map(f, [0, 1])
+map(f, map_fn = [0, 1])

src/wasm-lib/kcl/tests/array_elem_push/ast.snap

@@ -1,6 +1,8 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 55
 description: Result of parsing array_elem_push.kcl
+snapshot_kind: text
 ---
 {
   "Ok": {
@@ -57,46 +59,53 @@ description: Result of parsing array_elem_push.kcl
       },
       {
         "declaration": {
-          "end": 39,
+          "end": 45,
           "id": {
-            "end": 24,
-            "name": "new_arr1",
+            "end": 23,
+            "name": "newArr1",
             "start": 16,
             "type": "Identifier"
           },
           "init": {
             "arguments": [
               {
-                "end": 35,
-                "name": "arr",
-                "start": 32,
-                "type": "Identifier",
-                "type": "Identifier"
-              },
-              {
-                "end": 38,
-                "raw": "4",
-                "start": 37,
-                "type": "Literal",
-                "type": "Literal",
-                "value": 4.0
+                "type": "LabeledArg",
+                "label": {
+                  "type": "Identifier",
+                  "name": "elem"
+                },
+                "arg": {
+                  "end": 44,
+                  "raw": "4",
+                  "start": 43,
+                  "type": "Literal",
+                  "type": "Literal",
+                  "value": 4.0
+                }
               }
             ],
             "callee": {
-              "end": 31,
+              "end": 30,
               "name": "push",
-              "start": 27,
+              "start": 26,
               "type": "Identifier"
             },
-            "end": 39,
-            "start": 27,
-            "type": "CallExpression",
-            "type": "CallExpression"
+            "end": 45,
+            "start": 26,
+            "type": "CallExpressionKw",
+            "type": "CallExpressionKw",
+            "unlabeled": {
+              "end": 34,
+              "name": "arr",
+              "start": 31,
+              "type": "Identifier",
+              "type": "Identifier"
+            }
           },
           "start": 16,
           "type": "VariableDeclarator"
         },
-        "end": 39,
+        "end": 45,
         "kind": "const",
         "start": 16,
         "type": "VariableDeclaration",
@@ -104,647 +113,654 @@ description: Result of parsing array_elem_push.kcl
       },
       {
         "declaration": {
-          "end": 68,
+          "end": 79,
           "id": {
-            "end": 48,
-            "name": "new_arr2",
-            "start": 40,
+            "end": 53,
+            "name": "newArr2",
+            "start": 46,
             "type": "Identifier"
           },
           "init": {
             "arguments": [
               {
-                "end": 64,
-                "name": "new_arr1",
-                "start": 56,
-                "type": "Identifier",
-                "type": "Identifier"
-              },
-              {
-                "end": 67,
-                "raw": "5",
-                "start": 66,
-                "type": "Literal",
-                "type": "Literal",
-                "value": 5.0
+                "type": "LabeledArg",
+                "label": {
+                  "type": "Identifier",
+                  "name": "elem"
+                },
+                "arg": {
+                  "end": 78,
+                  "raw": "5",
+                  "start": 77,
+                  "type": "Literal",
+                  "type": "Literal",
+                  "value": 5.0
+                }
               }
             ],
             "callee": {
-              "end": 55,
+              "end": 60,
               "name": "push",
-              "start": 51,
+              "start": 56,
               "type": "Identifier"
             },
-            "end": 68,
-            "start": 51,
-            "type": "CallExpression",
-            "type": "CallExpression"
+            "end": 79,
+            "start": 56,
+            "type": "CallExpressionKw",
+            "type": "CallExpressionKw",
+            "unlabeled": {
+              "end": 68,
+              "name": "newArr1",
+              "start": 61,
+              "type": "Identifier",
+              "type": "Identifier"
+            }
           },
-          "start": 40,
+          "start": 46,
           "type": "VariableDeclarator"
         },
-        "end": 68,
+        "end": 79,
         "kind": "const",
-        "start": 40,
+        "start": 46,
         "type": "VariableDeclaration",
         "type": "VariableDeclaration"
       },
       {
-        "end": 142,
+        "end": 152,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 92,
+              "end": 102,
               "object": {
-                "end": 89,
-                "name": "new_arr1",
-                "start": 81,
+                "end": 99,
+                "name": "newArr1",
+                "start": 92,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 91,
+                "end": 101,
                 "raw": "0",
-                "start": 90,
+                "start": 100,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 0.0
               },
-              "start": 81,
+              "start": 92,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 95,
+              "end": 105,
               "raw": "1",
-              "start": 94,
+              "start": 104,
               "type": "Literal",
               "type": "Literal",
               "value": 1.0
             },
             {
-              "end": 104,
+              "end": 114,
               "raw": "0.00001",
-              "start": 97,
+              "start": 107,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 141,
+              "end": 151,
               "raw": "\"element 0 should not have changed\"",
-              "start": 106,
+              "start": 116,
               "type": "Literal",
               "type": "Literal",
               "value": "element 0 should not have changed"
             }
           ],
           "callee": {
-            "end": 80,
+            "end": 91,
             "name": "assertEqual",
-            "start": 69,
+            "start": 80,
             "type": "Identifier"
           },
-          "end": 142,
-          "start": 69,
+          "end": 152,
+          "start": 80,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 69,
+        "start": 80,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 216,
+        "end": 225,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 166,
+              "end": 175,
               "object": {
-                "end": 163,
-                "name": "new_arr1",
-                "start": 155,
+                "end": 172,
+                "name": "newArr1",
+                "start": 165,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 165,
+                "end": 174,
                 "raw": "1",
-                "start": 164,
+                "start": 173,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 1.0
               },
-              "start": 155,
+              "start": 165,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
-            {
-              "end": 169,
-              "raw": "2",
-              "start": 168,
-              "type": "Literal",
-              "type": "Literal",
-              "value": 2.0
-            },
             {
               "end": 178,
+              "raw": "2",
+              "start": 177,
+              "type": "Literal",
+              "type": "Literal",
+              "value": 2.0
+            },
+            {
+              "end": 187,
               "raw": "0.00001",
-              "start": 171,
+              "start": 180,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 215,
+              "end": 224,
               "raw": "\"element 1 should not have changed\"",
-              "start": 180,
+              "start": 189,
               "type": "Literal",
               "type": "Literal",
               "value": "element 1 should not have changed"
             }
           ],
           "callee": {
-            "end": 154,
+            "end": 164,
             "name": "assertEqual",
-            "start": 143,
+            "start": 153,
             "type": "Identifier"
           },
-          "end": 216,
-          "start": 143,
+          "end": 225,
+          "start": 153,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 143,
+        "start": 153,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 290,
+        "end": 298,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 240,
+              "end": 248,
               "object": {
-                "end": 237,
-                "name": "new_arr1",
-                "start": 229,
+                "end": 245,
+                "name": "newArr1",
+                "start": 238,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 239,
+                "end": 247,
                 "raw": "2",
-                "start": 238,
+                "start": 246,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 2.0
               },
-              "start": 229,
+              "start": 238,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 243,
+              "end": 251,
               "raw": "3",
-              "start": 242,
+              "start": 250,
               "type": "Literal",
               "type": "Literal",
               "value": 3.0
             },
             {
-              "end": 252,
+              "end": 260,
               "raw": "0.00001",
-              "start": 245,
+              "start": 253,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 289,
+              "end": 297,
               "raw": "\"element 2 should not have changed\"",
-              "start": 254,
+              "start": 262,
               "type": "Literal",
               "type": "Literal",
               "value": "element 2 should not have changed"
             }
           ],
           "callee": {
-            "end": 228,
+            "end": 237,
             "name": "assertEqual",
-            "start": 217,
+            "start": 226,
             "type": "Identifier"
           },
-          "end": 290,
-          "start": 217,
+          "end": 298,
+          "start": 226,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 217,
+        "start": 226,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 366,
+        "end": 373,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 314,
+              "end": 321,
               "object": {
-                "end": 311,
-                "name": "new_arr1",
-                "start": 303,
+                "end": 318,
+                "name": "newArr1",
+                "start": 311,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 313,
+                "end": 320,
                 "raw": "3",
-                "start": 312,
+                "start": 319,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 3.0
               },
-              "start": 303,
+              "start": 311,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 317,
+              "end": 324,
               "raw": "4",
-              "start": 316,
+              "start": 323,
               "type": "Literal",
               "type": "Literal",
               "value": 4.0
             },
             {
-              "end": 326,
+              "end": 333,
               "raw": "0.00001",
-              "start": 319,
+              "start": 326,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 365,
+              "end": 372,
               "raw": "\"4 was added to the end of the array\"",
-              "start": 328,
+              "start": 335,
               "type": "Literal",
               "type": "Literal",
               "value": "4 was added to the end of the array"
             }
           ],
           "callee": {
-            "end": 302,
+            "end": 310,
             "name": "assertEqual",
-            "start": 291,
+            "start": 299,
             "type": "Identifier"
           },
-          "end": 366,
-          "start": 291,
+          "end": 373,
+          "start": 299,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 291,
+        "start": 299,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 440,
+        "end": 446,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 390,
+              "end": 396,
               "object": {
-                "end": 387,
-                "name": "new_arr2",
-                "start": 379,
+                "end": 393,
+                "name": "newArr2",
+                "start": 386,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 389,
+                "end": 395,
                 "raw": "0",
-                "start": 388,
+                "start": 394,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 0.0
               },
-              "start": 379,
+              "start": 386,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 393,
+              "end": 399,
               "raw": "1",
-              "start": 392,
+              "start": 398,
               "type": "Literal",
               "type": "Literal",
               "value": 1.0
             },
             {
-              "end": 402,
+              "end": 408,
               "raw": "0.00001",
-              "start": 395,
+              "start": 401,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 439,
+              "end": 445,
               "raw": "\"element 0 should not have changed\"",
-              "start": 404,
+              "start": 410,
               "type": "Literal",
               "type": "Literal",
               "value": "element 0 should not have changed"
             }
           ],
           "callee": {
-            "end": 378,
+            "end": 385,
             "name": "assertEqual",
-            "start": 367,
+            "start": 374,
             "type": "Identifier"
           },
-          "end": 440,
-          "start": 367,
+          "end": 446,
+          "start": 374,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 367,
+        "start": 374,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 514,
+        "end": 519,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 464,
+              "end": 469,
               "object": {
-                "end": 461,
-                "name": "new_arr2",
-                "start": 453,
+                "end": 466,
+                "name": "newArr2",
+                "start": 459,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 463,
+                "end": 468,
                 "raw": "1",
-                "start": 462,
+                "start": 467,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 1.0
               },
-              "start": 453,
+              "start": 459,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 467,
+              "end": 472,
               "raw": "2",
-              "start": 466,
+              "start": 471,
               "type": "Literal",
               "type": "Literal",
               "value": 2.0
             },
             {
-              "end": 476,
+              "end": 481,
               "raw": "0.00001",
-              "start": 469,
+              "start": 474,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 513,
+              "end": 518,
               "raw": "\"element 1 should not have changed\"",
-              "start": 478,
+              "start": 483,
               "type": "Literal",
               "type": "Literal",
               "value": "element 1 should not have changed"
             }
           ],
           "callee": {
-            "end": 452,
+            "end": 458,
             "name": "assertEqual",
-            "start": 441,
+            "start": 447,
             "type": "Identifier"
           },
-          "end": 514,
-          "start": 441,
+          "end": 519,
+          "start": 447,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 441,
+        "start": 447,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 588,
+        "end": 592,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 538,
+              "end": 542,
               "object": {
-                "end": 535,
-                "name": "new_arr2",
-                "start": 527,
+                "end": 539,
+                "name": "newArr2",
+                "start": 532,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 537,
+                "end": 541,
                 "raw": "2",
-                "start": 536,
+                "start": 540,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 2.0
               },
-              "start": 527,
+              "start": 532,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 541,
+              "end": 545,
               "raw": "3",
-              "start": 540,
+              "start": 544,
               "type": "Literal",
               "type": "Literal",
               "value": 3.0
             },
             {
-              "end": 550,
+              "end": 554,
               "raw": "0.00001",
-              "start": 543,
+              "start": 547,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 587,
+              "end": 591,
               "raw": "\"element 2 should not have changed\"",
-              "start": 552,
+              "start": 556,
               "type": "Literal",
               "type": "Literal",
               "value": "element 2 should not have changed"
             }
           ],
           "callee": {
-            "end": 526,
+            "end": 531,
             "name": "assertEqual",
-            "start": 515,
+            "start": 520,
             "type": "Identifier"
           },
-          "end": 588,
-          "start": 515,
+          "end": 592,
+          "start": 520,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 515,
+        "start": 520,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 664,
+        "end": 667,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 612,
+              "end": 615,
               "object": {
-                "end": 609,
-                "name": "new_arr2",
-                "start": 601,
+                "end": 612,
+                "name": "newArr2",
+                "start": 605,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 611,
+                "end": 614,
                 "raw": "3",
-                "start": 610,
+                "start": 613,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 3.0
               },
-              "start": 601,
+              "start": 605,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 615,
+              "end": 618,
               "raw": "4",
-              "start": 614,
+              "start": 617,
               "type": "Literal",
               "type": "Literal",
               "value": 4.0
             },
             {
-              "end": 624,
+              "end": 627,
               "raw": "0.00001",
-              "start": 617,
+              "start": 620,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 663,
+              "end": 666,
               "raw": "\"4 was added to the end of the array\"",
-              "start": 626,
+              "start": 629,
               "type": "Literal",
               "type": "Literal",
               "value": "4 was added to the end of the array"
             }
           ],
           "callee": {
-            "end": 600,
+            "end": 604,
             "name": "assertEqual",
-            "start": 589,
+            "start": 593,
             "type": "Identifier"
           },
-          "end": 664,
-          "start": 589,
+          "end": 667,
+          "start": 593,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 589,
+        "start": 593,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       },
       {
-        "end": 740,
+        "end": 742,
         "expression": {
           "arguments": [
             {
               "computed": false,
-              "end": 688,
+              "end": 690,
               "object": {
-                "end": 685,
-                "name": "new_arr2",
-                "start": 677,
+                "end": 687,
+                "name": "newArr2",
+                "start": 680,
                 "type": "Identifier",
                 "type": "Identifier"
               },
               "property": {
-                "end": 687,
+                "end": 689,
                 "raw": "4",
-                "start": 686,
+                "start": 688,
                 "type": "Literal",
                 "type": "Literal",
                 "value": 4.0
               },
-              "start": 677,
+              "start": 680,
               "type": "MemberExpression",
               "type": "MemberExpression"
             },
             {
-              "end": 691,
+              "end": 693,
               "raw": "5",
-              "start": 690,
+              "start": 692,
               "type": "Literal",
               "type": "Literal",
               "value": 5.0
             },
             {
-              "end": 700,
+              "end": 702,
               "raw": "0.00001",
-              "start": 693,
+              "start": 695,
               "type": "Literal",
               "type": "Literal",
               "value": 0.00001
             },
             {
-              "end": 739,
+              "end": 741,
               "raw": "\"5 was added to the end of the array\"",
-              "start": 702,
+              "start": 704,
               "type": "Literal",
               "type": "Literal",
               "value": "5 was added to the end of the array"
             }
           ],
           "callee": {
-            "end": 676,
+            "end": 679,
             "name": "assertEqual",
-            "start": 665,
+            "start": 668,
             "type": "Identifier"
           },
-          "end": 740,
-          "start": 665,
+          "end": 742,
+          "start": 668,
           "type": "CallExpression",
           "type": "CallExpression"
         },
-        "start": 665,
+        "start": 668,
         "type": "ExpressionStatement",
         "type": "ExpressionStatement"
       }
     ],
-    "end": 741,
+    "end": 743,
     "start": 0
   }
 }

src/wasm-lib/kcl/tests/array_elem_push/input.kcl

@@ -1,12 +1,12 @@
 arr = [1, 2, 3]
-new_arr1 = push(arr, 4)
-new_arr2 = push(new_arr1, 5)
-assertEqual(new_arr1[0], 1, 0.00001, "element 0 should not have changed")
-assertEqual(new_arr1[1], 2, 0.00001, "element 1 should not have changed")
-assertEqual(new_arr1[2], 3, 0.00001, "element 2 should not have changed")
-assertEqual(new_arr1[3], 4, 0.00001, "4 was added to the end of the array")
-assertEqual(new_arr2[0], 1, 0.00001, "element 0 should not have changed")
-assertEqual(new_arr2[1], 2, 0.00001, "element 1 should not have changed")
-assertEqual(new_arr2[2], 3, 0.00001, "element 2 should not have changed")
-assertEqual(new_arr2[3], 4, 0.00001, "4 was added to the end of the array")
-assertEqual(new_arr2[4], 5, 0.00001, "5 was added to the end of the array")
+newArr1 = push(arr, elem = 4)
+newArr2 = push(newArr1, elem = 5)
+assertEqual(newArr1[0], 1, 0.00001, "element 0 should not have changed")
+assertEqual(newArr1[1], 2, 0.00001, "element 1 should not have changed")
+assertEqual(newArr1[2], 3, 0.00001, "element 2 should not have changed")
+assertEqual(newArr1[3], 4, 0.00001, "4 was added to the end of the array")
+assertEqual(newArr2[0], 1, 0.00001, "element 0 should not have changed")
+assertEqual(newArr2[1], 2, 0.00001, "element 1 should not have changed")
+assertEqual(newArr2[2], 3, 0.00001, "element 2 should not have changed")
+assertEqual(newArr2[3], 4, 0.00001, "4 was added to the end of the array")
+assertEqual(newArr2[4], 5, 0.00001, "5 was added to the end of the array")

src/wasm-lib/kcl/tests/array_elem_push/program_memory.snap

@@ -1,6 +1,6 @@
 ---
 source: kcl/src/simulation_tests.rs
-assertion_line: 92
+assertion_line: 99
 description: Program memory after executing array_elem_push.kcl
 snapshot_kind: text
 ---
@@ -81,7 +81,7 @@ snapshot_kind: text
             }
           ]
         },
-        "new_arr1": {
+        "newArr1": {
           "type": "Array",
           "value": [
             {
@@ -129,8 +129,8 @@ snapshot_kind: text
               "__meta": [
                 {
                   "sourceRange": [
-                    37,
-                    38,
+                    43,
+                    44,
                     0
                   ]
                 }
@@ -140,14 +140,14 @@ snapshot_kind: text
           "__meta": [
             {
               "sourceRange": [
-                27,
-                39,
+                26,
+                45,
                 0
               ]
             }
           ]
         },
-        "new_arr2": {
+        "newArr2": {
           "type": "Array",
           "value": [
             {
@@ -195,8 +195,8 @@ snapshot_kind: text
               "__meta": [
                 {
                   "sourceRange": [
-                    37,
-                    38,
+                    43,
+                    44,
                     0
                   ]
                 }
@@ -208,8 +208,8 @@ snapshot_kind: text
               "__meta": [
                 {
                   "sourceRange": [
-                    66,
-                    67,
+                    77,
+                    78,
                     0
                   ]
                 }
@@ -219,8 +219,8 @@ snapshot_kind: text
           "__meta": [
             {
               "sourceRange": [
-                51,
-                68,
+                56,
+                79,
                 0
               ]
             }

src/wasm-lib/kcl/tests/array_elem_push_fail/ast.snap

@@ -1,6 +1,8 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 55
 description: Result of parsing array_elem_push_fail.kcl
+snapshot_kind: text
 ---
 {
   "Ok": {
@@ -57,7 +59,7 @@ description: Result of parsing array_elem_push_fail.kcl
       },
       {
         "declaration": {
-          "end": 40,
+          "end": 47,
           "id": {
             "end": 25,
             "name": "pushedArr",
@@ -67,19 +69,19 @@ description: Result of parsing array_elem_push_fail.kcl
           "init": {
             "arguments": [
               {
-                "end": 36,
-                "name": "arr",
-                "start": 33,
-                "type": "Identifier",
-                "type": "Identifier"
-              },
-              {
-                "end": 39,
-                "raw": "4",
-                "start": 38,
-                "type": "Literal",
-                "type": "Literal",
-                "value": 4.0
+                "type": "LabeledArg",
+                "label": {
+                  "type": "Identifier",
+                  "name": "elem"
+                },
+                "arg": {
+                  "end": 46,
+                  "raw": "4",
+                  "start": 45,
+                  "type": "Literal",
+                  "type": "Literal",
+                  "value": 4.0
+                }
               }
             ],
             "callee": {
@@ -88,15 +90,22 @@ description: Result of parsing array_elem_push_fail.kcl
               "start": 28,
               "type": "Identifier"
             },
-            "end": 40,
+            "end": 47,
             "start": 28,
-            "type": "CallExpression",
-            "type": "CallExpression"
+            "type": "CallExpressionKw",
+            "type": "CallExpressionKw",
+            "unlabeled": {
+              "end": 36,
+              "name": "arr",
+              "start": 33,
+              "type": "Identifier",
+              "type": "Identifier"
+            }
           },
           "start": 16,
           "type": "VariableDeclarator"
         },
-        "end": 40,
+        "end": 47,
         "kind": "const",
         "start": 16,
         "type": "VariableDeclaration",
@@ -104,46 +113,46 @@ description: Result of parsing array_elem_push_fail.kcl
       },
       {
         "declaration": {
-          "end": 54,
+          "end": 61,
           "id": {
-            "end": 45,
+            "end": 52,
             "name": "fail",
-            "start": 41,
+            "start": 48,
             "type": "Identifier"
           },
           "init": {
             "computed": false,
-            "end": 54,
+            "end": 61,
             "object": {
-              "end": 51,
+              "end": 58,
               "name": "arr",
-              "start": 48,
+              "start": 55,
               "type": "Identifier",
               "type": "Identifier"
             },
             "property": {
-              "end": 53,
+              "end": 60,
               "raw": "3",
-              "start": 52,
+              "start": 59,
               "type": "Literal",
               "type": "Literal",
               "value": 3.0
             },
-            "start": 48,
+            "start": 55,
             "type": "MemberExpression",
             "type": "MemberExpression"
           },
-          "start": 41,
+          "start": 48,
           "type": "VariableDeclarator"
         },
-        "end": 54,
+        "end": 61,
         "kind": "const",
-        "start": 41,
+        "start": 48,
         "type": "VariableDeclaration",
         "type": "VariableDeclaration"
       }
     ],
-    "end": 55,
+    "end": 62,
     "start": 0
   }
 }

src/wasm-lib/kcl/tests/array_elem_push_fail/execution_error.snap

@@ -1,12 +1,14 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 133
 description: Error from executing array_elem_push_fail.kcl
+snapshot_kind: text
 ---
 KCL UndefinedValue error
 
   × undefined value: The array doesn't have any item at index 3
    ╭─[3:8]
- 2 │ pushedArr = push(arr, 4)
+ 2 │ pushedArr = push(arr, elem = 4)
  3 │ fail = arr[3]
    ·        ──────
    ╰────

src/wasm-lib/kcl/tests/array_elem_push_fail/input.kcl

@@ -1,3 +1,3 @@
 arr = [1, 2, 3]
-pushedArr = push(arr, 4)
+pushedArr = push(arr, elem = 4)
 fail = arr[3]

src/wasm-lib/kcl/tests/double_map_fn/ast.snap

@@ -1,6 +1,8 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 55
 description: Result of parsing double_map_fn.kcl
+snapshot_kind: text
 ---
 {
   "Ok": {
@@ -117,7 +119,7 @@ description: Result of parsing double_map_fn.kcl
       },
       {
         "declaration": {
-          "end": 101,
+          "end": 119,
           "id": {
             "end": 50,
             "name": "ys",
@@ -136,17 +138,18 @@ description: Result of parsing double_map_fn.kcl
               {
                 "arguments": [
                   {
-                    "end": 66,
-                    "start": 65,
-                    "type": "PipeSubstitution",
-                    "type": "PipeSubstitution"
-                  },
-                  {
-                    "end": 77,
-                    "name": "increment",
-                    "start": 68,
-                    "type": "Identifier",
-                    "type": "Identifier"
+                    "type": "LabeledArg",
+                    "label": {
+                      "type": "Identifier",
+                      "name": "map_fn"
+                    },
+                    "arg": {
+                      "end": 86,
+                      "name": "increment",
+                      "start": 77,
+                      "type": "Identifier",
+                      "type": "Identifier"
+                    }
                   }
                 ],
                 "callee": {
@@ -155,40 +158,53 @@ description: Result of parsing double_map_fn.kcl
                   "start": 61,
                   "type": "Identifier"
                 },
-                "end": 78,
+                "end": 87,
                 "start": 61,
-                "type": "CallExpression",
-                "type": "CallExpression"
+                "type": "CallExpressionKw",
+                "type": "CallExpressionKw",
+                "unlabeled": {
+                  "end": 66,
+                  "start": 65,
+                  "type": "PipeSubstitution",
+                  "type": "PipeSubstitution"
+                }
               },
               {
                 "arguments": [
                   {
-                    "end": 89,
-                    "start": 88,
-                    "type": "PipeSubstitution",
-                    "type": "PipeSubstitution"
-                  },
-                  {
-                    "end": 100,
-                    "name": "increment",
-                    "start": 91,
-                    "type": "Identifier",
-                    "type": "Identifier"
+                    "type": "LabeledArg",
+                    "label": {
+                      "type": "Identifier",
+                      "name": "map_fn"
+                    },
+                    "arg": {
+                      "end": 118,
+                      "name": "increment",
+                      "start": 109,
+                      "type": "Identifier",
+                      "type": "Identifier"
+                    }
                   }
                 ],
                 "callee": {
-                  "end": 87,
+                  "end": 96,
                   "name": "map",
-                  "start": 84,
+                  "start": 93,
                   "type": "Identifier"
                 },
-                "end": 101,
-                "start": 84,
-                "type": "CallExpression",
-                "type": "CallExpression"
+                "end": 119,
+                "start": 93,
+                "type": "CallExpressionKw",
+                "type": "CallExpressionKw",
+                "unlabeled": {
+                  "end": 98,
+                  "start": 97,
+                  "type": "PipeSubstitution",
+                  "type": "PipeSubstitution"
+                }
               }
             ],
-            "end": 101,
+            "end": 119,
             "start": 53,
             "type": "PipeExpression",
             "type": "PipeExpression"
@@ -196,14 +212,14 @@ description: Result of parsing double_map_fn.kcl
           "start": 48,
           "type": "VariableDeclarator"
         },
-        "end": 101,
+        "end": 119,
         "kind": "const",
         "start": 48,
         "type": "VariableDeclaration",
         "type": "VariableDeclaration"
       }
     ],
-    "end": 102,
+    "end": 120,
     "nonCodeMeta": {
       "nonCodeNodes": {
         "0": [

src/wasm-lib/kcl/tests/double_map_fn/input.kcl

@@ -4,5 +4,5 @@ fn increment(i) {
 
 xs = [0..2]
 ys = xs
-  |> map(%, increment)
-  |> map(%, increment)
+  |> map(%, map_fn = increment)
+  |> map(%, map_fn = increment)

src/wasm-lib/kcl/tests/double_map_fn/program_memory.snap

@@ -1,5 +1,6 @@
 ---
 source: kcl/src/simulation_tests.rs
+assertion_line: 99
 description: Program memory after executing double_map_fn.kcl
 snapshot_kind: text
 ---
@@ -261,8 +262,8 @@ snapshot_kind: text
           "__meta": [
             {
               "sourceRange": [
-                84,
-                101,
+                93,
+                119,
                 0
               ]
             }