Go Expr: Overload == Operator For JSON & Fix 'Unknown Status'

Hey everyone! I'm diving into a fascinating challenge: overloading the equality operator (==) in Go to handle comparisons involving json.Number. I've run into a couple of snags, and I'm hoping to get your insights. Specifically, I'm working on creating a filter mechanism where I need to compare a field (potentially a json.Number) against a value in a configuration string. Let's break down what I've tried and where I'm facing issues.

The Code I'm Working With

First, let's take a look at the Go code I've written. I'm aiming to create a Filter that can be initialized with a configuration string. This string will contain the comparison logic, something like status==4. The goal is to evaluate this expression, potentially involving json.Number comparisons. Here's the code snippet:

type Filter interface {
	// ...
}

type exprFilter struct {
	p *vm.Program
}

type FilterEnv struct {
	JsonNumEq func(a json.Number, b any) bool
}

// NewFilter creates a filter
func NewFilter(config string) (Filter, error) {
	f := exprFilter{}
	if config == "" {
		return f, nil
	}
	opts := []expr.Option{
		expr.Env(FilterEnv{
			JsonNumEq: func(a json.Number, b any) bool {
				return fmt.Sprint(a) == fmt.Sprint(b)
			},
		}),
		expr.Operator("==", "JsonNumEq"),
	}

	p, err := expr.Compile(config, opts...)
	if err != nil {
		return f, err
	}
	f.p = p
	return f, nil
}

// ...
filter, err := NewFilter("status==4")
if err != nil { log.Fatal(err) }
// ...

In this code:

• I define a Filter interface and an exprFilter struct to implement it.
• The FilterEnv struct holds the JsonNumEq function, which is intended to handle the comparison between a json.Number and another value.
• The NewFilter function takes a configuration string and attempts to compile it using the expr package. This is where I'm trying to inject my custom JsonNumEq function to overload the == operator.
• I'm using expr.Operator to associate the == operator with my JsonNumEq function.

The Problem: "unknown name status"

When I run this code, I encounter the following error:

unknown name status (1:1)
 | status==4
 | ^

This error suggests that the expr compiler doesn't recognize status in the expression status==4. This leads me to my questions.

Question 1: Overloading == with Different Operand Types

Let's tackle the first question: Is it possible to overload the == operator in Go when the operands have different types? Specifically, can I make == work between a json.Number and an any (which could be an int, string, etc.)?

In Go, you can't directly overload operators in the same way you might in languages like C++ or Python. Go's design philosophy favors explicitness and simplicity, so it doesn't allow operator overloading in the traditional sense. However, the expr library provides a mechanism to define custom functions that can be associated with operators. This is what I'm trying to do with the expr.Operator option.

The key here is that the expr library isn't actually overloading the == operator at the language level. Instead, it's interpreting the expression and routing the comparison to the custom function I've defined (JsonNumEq). So, in the context of the expr library, yes, it is possible to effectively overload the == operator to work with different types, but it's happening within the confines of the expression evaluation.

To achieve this, you need to ensure that your custom function (JsonNumEq in this case) can handle the different types you expect to encounter. In my code, JsonNumEq takes a json.Number and an any, which should allow it to handle comparisons with various types. The conversion to strings using fmt.Sprint is a simple way to compare the values, but it might not be the most efficient or accurate approach for all cases. More robust solutions might involve type switching or numeric comparisons.

Question 2: Why the Filter Creation Failure?

Now, let's address the core issue: What's causing the filter creation to fail with the "unknown name status" error? This is where things get interesting, and where I need some help from you guys.

The error message "unknown name status" indicates that the expr compiler couldn't find a variable or function named status within the context it was given. This suggests that I haven't properly defined or made status available to the expression being compiled. Let's break down the potential reasons:

1. Missing Variable Definition: The most likely cause is that status is not defined as a variable within the environment provided to the expr compiler. The expr library needs to know about the variables used in the expression. I'm providing a FilterEnv with a JsonNumEq function, but I'm not providing any information about the status variable itself.
2. Incorrect Scope: Even if status were defined somewhere in my Go code, it might not be in the scope that the expr compiler is using. The expr library operates within its own environment, and it needs to be explicitly told about the variables and functions it can access.
3. Type Mismatch: Although less likely in this specific scenario, a type mismatch could also lead to this error. If status were defined but had an unexpected type, the expr compiler might not be able to process it correctly. However, the error message strongly suggests that the name itself is unknown, making this less probable.

To fix this, I need to tell the expr compiler about the status variable. This typically involves providing a struct or map that contains the variables and their values. The expr library can then access these variables during expression evaluation. Here's where I'm a bit stuck. I'm not sure how to best integrate the status variable into the expr environment within my NewFilter function. I suspect I need to modify the options passed to expr.Compile to include information about status, but I'm unsure of the exact syntax and approach.

Potential Solutions and Next Steps

I'm exploring a few potential solutions to this problem:

1. Using expr.Vars Option: The expr library provides an expr.Vars option that allows you to pass a map of variables to the compiler. I could create a map that includes status and its value, and then pass this map as an option to expr.Compile. This seems like the most direct approach.
2. Modifying FilterEnv: Another option might be to include status directly in the FilterEnv struct. However, this would require me to know the value of status at the time the filter is created, which might not always be the case. The value of status might only be available at runtime when the filter is actually applied.
3. Custom Evaluation Context: I could potentially create a custom evaluation context for the expr library. This would involve implementing an interface that the expr library uses to resolve variable names. This is a more advanced approach, but it might offer greater flexibility and control.

I'm leaning towards trying the expr.Vars option first, as it seems like the most straightforward solution. However, I'm open to suggestions and alternative approaches. Has anyone here worked with the expr library before and encountered similar issues? Any insights or guidance would be greatly appreciated!

Digging Deeper into the expr Library and Operator Overloading

Let's delve a bit deeper into the mechanics of the expr library and how it handles operator overloading, or rather, the simulation of it. As we've established, Go doesn't support operator overloading in the traditional sense like some other languages do. You can't redefine the behavior of operators like +, -, or == for custom types at the language level. However, libraries like expr offer a way to achieve similar functionality within their own expression evaluation context.

The expr library essentially parses a string expression and constructs an abstract syntax tree (AST) representing the expression's structure. When it encounters an operator like ==, it doesn't directly use Go's built-in equality operator. Instead, it looks up a function associated with that operator in its environment. This is where the expr.Operator option comes into play.

By using `expr.Operator(