Unless / If expressions support

what we could have is

unless(x>10){doSomething}

which is more or less like an if with a negated condition. The other order is a bit problematic in Groovy because there is no execution style like that in all of groovy. That would mean adding a new idiom, which makes the language more complicated. What could be done, would maybe:

{doSomething}.unless(x>10)

which is not exactly like in Python, but I think that is good enough. For this solution a category could be used to see if it is good.

That could indeed be a solution.

I understand that allowing the form I mentioned would require a change in the grammar. However I think that this would not require much changes. I am not familiar with the Groovy parser and the AST that it generates, but a naive solution would be to transform an AST such as:

            r_conditional("unless")
            /            \
      b=true_branch      c=condition

to:

            if (not c)
            /
            b

representing this in the AST is not the primary issue here. There are several idioms in Groovy and most of our grammar is based on different forms of method calls. For example

if (b) {println foo}

can be seen as a method call to the method "if" with two parameters that are "b" and the block "

". When I now look at

doSomething() unless (x > 10)

then I see a method call "doSomething()" like before with the if, but what follows? I can't be a method call if multiple arguments, because of the () and because no block follows. So what is it then? The solution I showed is based on an expression consisting of

{doSomething()}

and a method called on the result of that expression. So in my view it does not fit the overall style used in Groovy and I am tempted to say no to this, if your example is the only usage of a whole new idiom.

If we bring back in the do ... while loop, we could potentially support:

if (condition) { ... }
unless (condition) { ... }
do { ... } while (condition)
do { ... } if (condition)
do { ... } unless (condition)

Julien, I would suggest you raise the issue on the groovy-user list to see the reactions of others.

Done. Let's see what people think about the idea

+1000 for unless, except I think we should stick with pre statement rather post statement. To be clear...

unless (x > 10) doSomething()

if (x < 10) triggerSomethingNasty()

I actually prefer the ruby/perl style of having the condition afterwards for single statement expressions, but since Groovy already supports having the condition before the statement I would advocate sticking with this.

I think having conditions as right-hand side properties of an expression is awful – especially in a read left-to-right language. Just because Perl and Ruby do it doesn't make it good and desirable – Python doesn't have the structure as was originally stated.

My mistake, Python indeed doesn't have those constructs.

No problem, I just wanted to ensure no mistakes got turned into facts

It seems the debate is lively and alive on the mailing list, so I guess the best bet is to wait for things to iterate to a conclusion there and then post a summary item here.

What was the conclusion on the user list? If this is all too hard, why not just create a separate issue to add 'unless' and confine this issue to the idea of reverse-syntax.

The conclusion is that it's not a very natual style for Groovy to have that conditional after the statement.
So we're not really fond of implementing this feature.
We're keeping old feature requests open in our bug tracker though, hence why this issue is still open.