Hi all, 

I don't like how @(if) works as a syntactic sugar for a @(cases) with
@(require) clauses. It is confusing because it doesn't behave like a
nested if in other languages. 

Here is a synopsis of the problem: 

Consider: 

@(if _C1_)
_X_
@(elif _C2_)
 _Y_
@(end) 

Suppose that both conditions _C1_ and _C2_ are true. Then block _X_ will
be evaluated. Now suppose that _X_ triggers a failure. Oops; because of
the way this is defined, the pattern matcher will end up in _Y_. This is
because the failed case triggers the next case: it's just the @(cases)
construct in disguise. It falls through _C2_, which is true. 

Worse, _C2 _could be initially false, but made true by logic in _X_.
And, worse still, an @(else) clause is always evaluated if any of the
previous ones fail anywhere, not only on their conditions. 

It would be better for @(if) to have the intuitive semantics: select the
first clause for which the condition is true, and then remove any
subsequent clauses from consideration. 

That is to say, if the pattern-matcher descends into _X_ above, there
should be no possibility of condition _C2_ being evaluated and then _Y_.
If _X_ fails, then the @(if) fails. 

If I make this change, it will be subject to the backwards-compatibility
-C option, of course. I may also make the old behavior continue to be
available under some other operator name, like if* or whatever.