World: r3wp

such trick:
(cont: if zero? p: p - 1 ['break]) cont
doesn't work anymore IIRC

try without the '

i guess not, but i will try

it doesn't work

it's a broblem specificaly for the BREAK command, because it can't 
be encaped in a block, it has to be on the same level than the ANY/SOME 
block to be effective

yeah, cause it just breaks the block its in.

but with the IF command it should not be too much worrying

some rules will definitely need to be changed with the three hacks 
he now made officially "illegal"

but that should only affect.... hackers...  ;-)

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

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 :)