Use literal operators (eg "and", "or") in Groovy expressions?

Question

My current work project allows user-provided expressions to be evaluated in specific contexts, as a way for them to extend and influence the workflow. These expressions the usual logical ones f. To make it a bit palatable for non-programmers, I'd like to give them the option of using literal operators (e.g. and, or, not instead of &, |, !).

A simple search & replace is not sufficient, as the data might contains those words within quotes and building a parser, while doable, may not be the most elegant and efficient solution.

To make the question clear: is there a way in Groovy to allow the users to write

x > 10 and y = 20 or not z 

but have Groovy evaluate it as if it were:

x > 10 && y == 20 || !z

Thank you.

Answer 1

Recent versions of Groovy support Command chains, so it's indeed possible to write this:

compute x > 10 and y == 20 or not(z)

The word "compute" here is arbitrary, but it cannot be omitted, because it's the first "verb" in the command chain. Everything that follows alternates between verb and noun:

 compute  x > 10  and  y == 20  or   not(z)
 ───┬───  ──┬───  ─┬─  ───┬───  ─┬─  ──┬───
   verb    noun   verb   noun   verb  noun

A command chain is compiled like this:

verb(noun).verb(noun).verb(noun)...

so the example above is compiled to:

compute(x > 10).and(y == 20).or(not(z))

There are many ways to implement this. Here is just a quick & dirty proof of concept, that doesn't implement operator precedence, among other things:

class Compute {
    private value
    Compute(boolean v) { value = v }
    def or (boolean w) { value = value || w; this }
    def and(boolean w) { value = value && w; this }
    String  toString() { value }
}

def compute(v) { new Compute(v) }
def not(boolean v) { !v }

You can use command chains by themselves (as top-level statements) or to the right-hand side of an assignment operator (local variable or property assignment), but not inside other expressions.