Add lambda expression and map() + filter() functions with ARM syntax

dsc/src/subcommand.rs

@@ -672,6 +672,7 @@ fn list_functions(functions: &FunctionDispatcher, function_name: Option<&String>
     let returned_types= [
         (FunctionArgKind::Array, "a"),
         (FunctionArgKind::Boolean, "b"),
+        (FunctionArgKind::Lambda, "l"),
         (FunctionArgKind::Number, "n"),
         (FunctionArgKind::String, "s"),
         (FunctionArgKind::Object, "o"),

dsc/tests/dsc_lambda.tests.ps1

@@ -0,0 +1,134 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+Describe 'map() function with lambda tests' {
+    It 'map with simple lambda multiplies each element by 2' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+parameters:
+  numbers:
+    type: array
+    defaultValue: [1, 2, 3]
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[map(parameters('numbers'), lambda('x', mul(lambdaVariables('x'), 2)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output | Should -Be @(2,4,6)
+    }
+
+    It 'map with lambda using index parameter' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+parameters:
+  items:
+    type: array
+    defaultValue: [10, 20, 30]
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[map(parameters('items'), lambda('val', 'i', add(lambdaVariables('val'), lambdaVariables('i'))))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output | Should -Be @(10,21,32)
+    }
+
+    It 'map with range generates array' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[map(range(0, 3), lambda('x', mul(lambdaVariables('x'), 3)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output | Should -Be @(0,3,6)
+    }
+
+    It 'map returns empty array for empty input' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[map(createArray(), lambda('x', mul(lambdaVariables('x'), 2)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output.Count | Should -Be 0
+    }
+}
+
+Describe 'filter() function with lambda tests' {
+    It 'filter with simple lambda filters elements greater than 2' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+parameters:
+  numbers:
+    type: array
+    defaultValue: [1, 2, 3, 4, 5]
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[filter(parameters('numbers'), lambda('x', greater(lambdaVariables('x'), 2)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output | Should -Be @(3,4,5)
+    }
+
+    It 'filter with lambda using index parameter' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+parameters:
+  items:
+    type: array
+    defaultValue: [10, 20, 30, 40]
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[filter(parameters('items'), lambda('val', 'i', less(lambdaVariables('i'), 2)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output | Should -Be @(10,20)
+    }
+
+    It 'filter returns empty array when no elements match' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[filter(createArray(1, 2, 3), lambda('x', greater(lambdaVariables('x'), 10)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output.Count | Should -Be 0
+    }
+
+    It 'filter returns all elements when all match' {
+        $config_yaml = @'
+$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
+resources:
+- name: Echo
+  type: Microsoft.DSC.Debug/Echo
+  properties:
+    output: "[filter(createArray(5, 6, 7), lambda('x', greater(lambdaVariables('x'), 2)))]"
+'@
+        $out = $config_yaml | dsc config get -f - | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $out.results[0].result.actualState.output | Should -Be @(5,6,7)
+    }
+}

lib/dsc-lib/locales/en-us.toml

@@ -247,9 +247,12 @@ argCountRequired = "Function '%{name}' requires between %{min_args} and %{max_ar
 noArrayArgs = "Function '%{name}' does not accept array arguments, accepted types are: %{accepted_args_string}"
 noBooleanArgs = "Function '%{name}' does not accept boolean arguments, accepted types are: %{accepted_args_string}"
 noNumberArgs = "Function '%{name}' does not accept number arguments, accepted types are: %{accepted_args_string}"
+noLambdaArgs = "Function '%{name}' does not accept lambda arguments, accepted types are: %{accepted_args_string}"
 noNullArgs = "Function '%{name}' does not accept null arguments, accepted types are: %{accepted_args_string}"
 noObjectArgs = "Function '%{name}' does not accept object arguments, accepted types are: %{accepted_args_string}"
 noStringArgs = "Function '%{name}' does not accept string arguments, accepted types are: %{accepted_args_string}"
+lambdaNotFound = "Function '%{name}' could not find lambda with ID '%{id}'"
+lambdaTooManyParams = "Function '%{name}' requires lambda with 1 or 2 parameters (element and optional index)"
 
 [functions.add]
 description = "Adds two or more numbers together"
@@ -344,6 +347,11 @@ description = "Evaluates if the two values are the same"
 description = "Returns the boolean value false"
 invoked = "false function"
 
+[functions.filter]
+description = "Filters an array with a custom filtering function"
+invoked = "filter function"
+lambdaMustReturnBool = "filter() lambda must return a boolean value"
+
 [functions.first]
 description = "Returns the first element of an array or first character of a string"
 invoked = "first function"
@@ -409,11 +417,27 @@ invalidObjectElement = "Array elements cannot be objects"
 description = "Converts a valid JSON string into a JSON data type"
 invalidJson = "Invalid JSON string"
 
+[functions.lambda]
+description = "Creates a lambda function with parameters and a body expression"
+invoked = "lambda function"
+requiresParamAndBody = "lambda() requires at least one parameter name and a body expression"
+paramsMustBeStrings = "lambda() parameter names must be string literals"
+bodyMustBeExpression = "lambda() body must be an expression"
+
+[functions.lambdaVariables]
+description = "Retrieves the value of a lambda parameter"
+invoked = "lambdaVariables function"
+notFound = "Lambda parameter '%{name}' not found in current context"
+
 [functions.lastIndexOf]
 description = "Returns the index of the last occurrence of an item in an array"
 invoked = "lastIndexOf function"
 invalidArrayArg = "First argument must be an array"
 
+[functions.map]
+description = "Transforms an array by applying a lambda function to each element"
+invoked = "map function"
+
 [functions.length]
 description = "Returns the length of a string, array, or object"
 invoked = "length function"
@@ -683,6 +707,7 @@ functionName = "Function name: '%{name}'"
 argIsExpression = "Argument is an expression"
 argIsValue = "Argument is a value: '%{value}'"
 unknownArgType = "Unknown argument type '%{kind}'"
+unexpectedLambda = "Lambda expressions cannot be used as function arguments directly. Use the lambda() function to create a lambda expression."
 
 [parser]
 parsingStatement = "Parsing statement: %{statement}"

lib/dsc-lib/src/configure/context.rs

@@ -12,6 +12,7 @@ use super::config_doc::{DataType, RestartRequired, SecurityContextKind};
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum ProcessMode {
     Copy,
+    Lambda,
     Normal,
     NoExpressionEvaluation,
     ParametersDefault,
@@ -25,6 +26,9 @@ pub struct Context {
     pub dsc_version: Option<String>,
     pub execution_type: ExecutionKind,
     pub extensions: Vec<DscExtension>,
+    pub lambda_raw_args: std::cell::RefCell<Option<Vec<crate::parser::functions::FunctionArg>>>,
+    pub lambda_variables: HashMap<String, Value>,
+    pub lambdas: std::cell::RefCell<HashMap<String, crate::parser::functions::Lambda>>,
     pub outputs: Map<String, Value>,
     pub parameters: HashMap<String, (Value, DataType)>,
     pub process_expressions: bool,
@@ -49,6 +53,9 @@ impl Context {
             dsc_version: None,
             execution_type: ExecutionKind::Actual,
             extensions: Vec::new(),
+            lambda_raw_args: std::cell::RefCell::new(None),
+            lambda_variables: HashMap::new(),
+            lambdas: std::cell::RefCell::new(HashMap::new()),
             outputs: Map::new(),
             parameters: HashMap::new(),
             process_expressions: true,

lib/dsc-lib/src/functions/filter.rs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{FunctionArgKind, Function, FunctionCategory, FunctionMetadata};
+use crate::functions::lambda_helpers::{get_lambda, apply_lambda_to_array};
+use rust_i18n::t;
+use serde_json::Value;
+use tracing::debug;
+
+#[derive(Debug, Default)]
+pub struct Filter {}
+
+impl Function for Filter {
+    fn get_metadata(&self) -> FunctionMetadata {
+        FunctionMetadata {
+            name: "filter".to_string(),
+            description: t!("functions.filter.description").to_string(),
+            category: vec![FunctionCategory::Array, FunctionCategory::Lambda],
+            min_args: 2,
+            max_args: 2,
+            accepted_arg_ordered_types: vec![
+                vec![FunctionArgKind::Array],
+                vec![FunctionArgKind::Lambda],
+            ],
+            remaining_arg_accepted_types: None,
+            return_types: vec![FunctionArgKind::Array],
+        }
+    }
+
+    fn invoke(&self, args: &[Value], context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.filter.invoked"));
+
+        let array = args[0].as_array().unwrap();
+        let lambda_id = args[1].as_str().unwrap();
+
+        let lambdas = get_lambda(context, lambda_id, "filter")?;
+        let lambda = lambdas.get(lambda_id).unwrap();
+
+        let result_array = apply_lambda_to_array(array, lambda, context, |result, element| {
+            let Some(include) = result.as_bool() else {
+                return Err(DscError::Parser(t!("functions.filter.lambdaMustReturnBool").to_string()));
+            };
+            if include {
+                Ok(Some(element.clone()))
+            } else {
+                Ok(None)
+            }
+        })?;
+
+        Ok(Value::Array(result_array))
+    }
+}

lib/dsc-lib/src/functions/lambda.rs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{FunctionArgKind, Function, FunctionCategory, FunctionMetadata};
+use crate::parser::functions::{FunctionArg, Lambda};
+use rust_i18n::t;
+use serde_json::Value;
+use tracing::debug;
+use uuid::Uuid;
+
+#[derive(Debug, Default)]
+pub struct LambdaFn {}
+
+impl Function for LambdaFn {
+    fn get_metadata(&self) -> FunctionMetadata {
+        FunctionMetadata {
+            name: "lambda".to_string(),
+            description: t!("functions.lambda.description").to_string(),
+            category: vec![FunctionCategory::Lambda],
+            min_args: 0, // Args come through context.lambda_raw_args
+            max_args: 0,
+            accepted_arg_ordered_types: vec![],
+            remaining_arg_accepted_types: None,
+            return_types: vec![FunctionArgKind::Lambda],
+        }
+    }
+
+    fn invoke(&self, _args: &[Value], context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.lambda.invoked"));
+
+        let raw_args = context.lambda_raw_args.borrow();
+        let args = raw_args.as_ref()
+            .filter(|a| a.len() >= 2)
+            .ok_or_else(|| DscError::Parser(t!("functions.lambda.requiresParamAndBody").to_string()))?;
+
+        let (body_arg, param_args) = args.split_last().unwrap(); // safe: len >= 2
+
+        let parameters: Vec<String> = param_args.iter()
+            .map(|arg| match arg {
+                FunctionArg::Value(Value::String(s)) => Ok(s.clone()),
+                _ => Err(DscError::Parser(t!("functions.lambda.paramsMustBeStrings").to_string())),
+            })
+            .collect::<Result<_, _>>()?;
+
+        // Extract body expression
+        let body = match body_arg {
+            FunctionArg::Expression(expr) => expr.clone(),
+            _ => return Err(DscError::Parser(t!("functions.lambda.bodyMustBeExpression").to_string())),
+        };
+
+        // Create Lambda and store in Context with unique ID
+        let lambda = Lambda { parameters, body };
+        let lambda_id = format!("__lambda_{}", Uuid::new_v4());
+        context.lambdas.borrow_mut().insert(lambda_id.clone(), lambda);
+
+        Ok(Value::String(lambda_id))
+    }
+}