Question

I mean this:

bool passed = true;
for(int i = 0; i < collection.Length; i++)
{
    if(!PassesTest(collection[i]))
    {
        passed = false;
        break;
    }
}
if(passed){/*passed code*/}

requires extra variable, extra test

for(int i = 0; i < collection.Length; i++)
{
    if(!PassesTest(collection[i]))
    {
        return;
    }
}
{/*passed code*/}

neat, but requires this to be it’s own function, if this it’s self is inside a loop or something, not the most performant way of doing things. also, writing a whole extra function is a pain

if(passed){/*passed code*/}
for(int i = 0; i < collection.Length; i++)
{
    if(!PassesTest(collection[i]))
    {
        goto failed;
    }
}
{/*passed code*/}
failed: {}

great, but you have to screw around with label names and ugly label syntax

for(int i = 0; ; i++)
{
    if(!(i < collection.Length))
    {
         {/*passed code*/}
         break;
    }
    if(!PassesTest(collection[i]))
    {
        break;
    }
}

probably the nicest, but still a bit manual, kinda wasting the functionality of the for loop construct, for instance, you can’t do this with a foreach

what is the nicest way to handle this problem?

it seems to me something like this would be nice:
foreach(…)
{
…
}
finally{…} // only executed if loop ends conventionally (without break)

am I missing something? because this is a very common problem for me, and I don’t really like any of the solutions I’ve come up with.

I use c++ and C#, so solutions in either would be great.
but would also be interested in solutions in other languages. (though a design principle that avoids this in any language would be ideal)

Answer 1

If your language doesn’t have this feature, write a function “forall,” which takes two arguments: a list and a boolean-valued function which is to be true for all elements of the list. Then you only have to write it once, and it matters very little how idiomatic it is.

The “forall” function looks exactly like your second code sample, except that now “collection” and “passesTest” are the arguments to that function.

Calling forall looks roughly like:

if (forall(myList,isGood)) {

which is readable.

As an added bonus, you could implement “exists” by calling “forall” on the negated boolean function, and negating its answer. That is, “exists x P(x)” is implemented as “not forall x not P(x)”.