World: r3wp

On one line:

rule: [(p: 0) any [#"(" (++ p) | #")" if (1 >= -- p) then break | 
none] if (p = 0)]

As i thought, we are saved :-)

Needs some tweaking though.

the   [IF () THEN rule | rule ]  reads nicely when used in parse 
rules. I find.

a smell of old BASIC

hehe  yeah... that's it  ;-)

what's that if (p=0) at the tail ?

Checks to see if the counter is even. Badly, I'm afraid, needs tweaking 
(which I'm doing now).

why not use  'EVEN?

EVEN? you mean negative ?

it can't be...

Even, meaning the ( and ) are balanced. p starts as 0, and should 
end as 0.

yep, it can't exit the loop without equality

except if it's the end. So,  your final condition is [not end]

not enough....

yep, you have to check that for

rule: [(p: 0) any [#"(" (++ p) | #")" if (1 <= -- p) then none | 
break] if (p = 0)]

That works. If there is remaining input when you run out of rules, 
that coounts as failure.

It took reversing the if then condition to do it.

>> parse "(()" [(p: 0) any [#"(" (++ p) | #")" if (1 <= -- p) then 
none | break] if (p = 0)]
== false

>> parse "(())" [(p: 0) any [#"(" (++ p) | #")" if (1 <= -- p) then 
none | break] if (p = 0)]
== true

>> parse "())" [(p: 0) any [#"(" (++ p) | #")" if (1 <= -- p) then 
none | break] if (p = 0)]
== false

>> parse ")(" [(p: 0) any [#"(" (++ p) | #")" if (1 <= -- p) then 
none | break] if (p = 0)]
== false

This kind of thing is why I suggested IF (as CHECK) 5 years ago :)

to optimize a little, i would prevent from useless entering in the 
any loop:

[#"(" (p: 1) some  [#"(" (++ p) | #")" if (1 <= -- p) then none | 
break] if (p = 0)]

but now, the  (1 <= -- p) condition is false i mean

[(p: 0) some [#"(" (++ p) | #")" if (1 <= -- p) then none | break] 
if (p = 0)]

Handles the empty string. Given the | break alternate, ANY and SOME 
are equivalent.

Yours would work, but wouldn't recognize an empty string.

still, aren't the condition (1 <= -- p) wrong ?

-- decrements but returns previous value

You want the condition to be false, so the break is chosen.

if p = 1 then it must break

No, you want to break when p is 0 or less.

Even in your version.

wait...

The | break is not only the else for the if (), it is also the alternate 
chosen if #"(" or #")" are not matched.

That is what THEN gives us: the ability to overload alternates.

oh ok, it's not exiting the loop for such case [()()()()]

Right :)

Am ok now

But we *want* to exit the loop in this case: ")("

yep

I find myself liking THEN quite a bit :)

But we still have a problem with break not being able encapable in 
a block.
We can't construct reusable rules with such logic.

i mean we can't push the part [if (1 <= -- p) then none | break] 
in a separated rule

we need a parameter for break

It's tricky, true. There was either a proposal or a bug report to 
make BREAK break out of the closest enclosing ANY or SOME...

break level

break 0

break -1

Counted back, not negative.

if you prefer

time for a new proposal Brian