How to implement one formula in another formula

[star2478]

Hi,
I created two formulas: IIF and Coalesce.

They can work when used alone, such as IIF(true, "eee", "fff"), Coalesce(email, enterprise_email, aa, "abc").

However, it can't work when one used in another, such as Coalesce(email, enterprise_email, aa, IIF(true, "eee", "fff"), "abc"). How to implement it?

// IIF formula
iifFunc := expr.Function(
		"IIF",
		func(params ...any) (any, error) {
			if params[0].(bool) {
				return params[1], nil
			} else {
				return params[2], nil
			}
		},
)
exprStr := `IIF(true, "eee", "fff")`
program, err := expr.Compile(exprStr, iifFunc)
env := map[string]interface{}{
		"xx": "a2",
}
output, err := expr.Run(program, env)
fmt.Println(output) // eee

///////////////////////////////////
// Coalesce formula
coalesceFunc := expr.Function(
	"Coalesce",
	func(params ...any) (any, error) {
		lenParams := len(params)
		i := 0
		for {
			if i >= lenParams {
				return params[lenParams-1], nil
			}
			if params[i] != nil && params[i].(string) != "" {
				return params[i], nil
			}
			i++
		}
	},
)
exprCoalesce := `Coalesce(email, enterprise_email, aa, "abc")`
program, err = expr.Compile(exprCoalesce, coalesceFunc)
if err != nil {
	panic(err)
}
env = map[string]interface{}{
	"email":            "",
	"enterprise_email": "",
}
if output, err = expr.Run(program, env); err != nil {
	panic(err)
}
fmt.Println(output) // abc

[star2478]

It can be resolved by putting iifFunc and coalesceFunc in expr.Option!

options := []expr.Option{
	iifFunc, coalesceFunc,
}
code := `Coalesce(email, enterprise_email, aa, IIF(false, "eee", "fff"), "abc")`
program, err = expr.Compile(code, options...)
if err != nil {
	fmt.Printf("%v", err)
	return
}
output, err = expr.Run(program, env)
if err != nil {
	fmt.Printf("%v", err)
	return
}
fmt.Printf("%v", output)

[antonmedv]

The issue arises because your custom functions IIF and Coalesce are defined separately, and the expr library doesn't automatically recognize how to nest them. To make IIF work inside Coalesce, you need to register both functions at the same time and ensure the expr compiler understands their contexts.

Here's how you can solve this:

1. Register Both Functions Together: When defining the environment for the expr.Compile, you need to provide both functions so they can recognize each other.

2. Update Your Functions: Adjust your custom functions to handle nested calls by ensuring the params can include already evaluated expressions.

Here’s the modified implementation:

package main

import (
	"fmt"
	"github.com/antonmedv/expr"
)

// IIF formula
func iifFunc(params ...any) (any, error) {
	if len(params) != 3 {
		return nil, fmt.Errorf("IIF requires 3 parameters")
	}
	condition, ok := params[0].(bool)
	if !ok {
		return nil, fmt.Errorf("first parameter of IIF must be a boolean")
	}
	if condition {
		return params[1], nil
	}
	return params[2], nil
}

// Coalesce formula
func coalesceFunc(params ...any) (any, error) {
	for _, param := range params {
		if param != nil {
			// Check for non-empty strings
			if str, ok := param.(string); ok && str != "" {
				return str, nil
			}
			// Return the first non-nil value
			return param, nil
		}
	}
	return nil, fmt.Errorf("no non-nil values in Coalesce")
}

func main() {
	// Define the custom functions
	functions := map[string]any{
		"IIF":      iifFunc,
		"Coalesce": coalesceFunc,
	}

	// Example usage
	exprStr := `Coalesce(email, enterprise_email, IIF(true, "eee", "fff"), "abc")`

	// Compile with both functions
	program, err := expr.Compile(exprStr, expr.Env(functions))
	if err != nil {
		panic(err)
	}

	// Define the environment
	env := map[string]interface{}{
		"email":            "",
		"enterprise_email": "",
	}

	// Run the program
	output, err := expr.Run(program, env)
	if err != nil {
		panic(err)
	}
	fmt.Println(output) // Output: eee
}

Key Adjustments:

1. Environment Setup: Both IIF and Coalesce are registered in the same environment using expr.Env.

2. Param Validation: Both functions handle nested calls by checking if parameters are already evaluated expressions.

3. Test Nesting: The example nests IIF within Coalesce, and it works seamlessly.

This approach ensures that the expr library correctly parses and evaluates nested custom functions.