I would love to see a comparison to library based solutions to this problem:

forEach(range, body, onsuccess, onerror) // onerror called on early exit

where body has a signature like "bool(T element, size_t index)" // return means "should_break"

This type of library solution could also be written to support a "between" callable (called between loop bodies, but not before first/after last element) etc. I'm not sure I see sufficient evidence of langage solution, especially given the amazing stuff happening with lambdas becoming easier to use.

And this (considering mmocny's comments) is exactly why the range-base for syntax should have never been accepted in favor of making for_each(v, [](auto el) do_something(el)); possible.

bkuhns, that wouldn't help here. There's still a need for a way to exit early. What you ask is actually possible though, as long as you don't need the std:: on the front of it:

[div class="codeblock"] template<typename C, typename F> F for_each(C &coll, F pFunc)
    {
    using std::begin;
    using std::end;
    return(std::for_each(begin(coll), end(coll), pFunc));
    }  [/div]

"I would love to see a comparison to library based solutions to this problem:"

This is just off the top of my head, I haven't actually used this, and I'm on the fence whether this should be considered an abuse of find_if:

[div class="codeblock"] template<typename C, typename F>
auto find_if(C &coll, F pFunc) -> decltype(std::begin(coll))
    {
    return(std::find_if(std::begin(coll), std::end(coll), pFunc));
    }

    auto last = find_if(c, [&](Foo const &v) -> bool
        {
        if(some_condition(v))
            return(true);
        do_something(v);
        return(false);
        });

    if(last == std::end(c))
        something();
    else
        do_something_else(last);  [/div]

or if you want it all in a single function:

[div class="codeblock"] template<typename C, typename P, typename N, typename E>
void for_each_extended(C &coll, P pred, N normal, E early)
    {
    auto i = find_if(coll, pred);
    if(i == std::end(coll))
        normal();
    else
        early(*i);
    }

    for_each_extended(c, [&](Foo const &v) -> bool
        {
        if(some_condition(v))
            return(true);
        do_something(v);
        return(false);
        },
    [&]() { something(); },
    [&](Foo const &v) { something_else(v); });  [/div]

"especially given the amazing stuff happening with lambdas becoming easier to use."

If I understand the proposed lambda changes correctly, that would give us this:

[div class="codeblock"] for_each_extended(c, [](auto v)
        {
        if(some_condition(v))
            return(true);
        do_something(v);
        return(false);
        },
    [] something(),
    [](auto v) something_else(v));  [/div]

@Greg Marr I love what you've provided, and is entirely along the lines of what I was thinking. This would be a great addition to the standard library, especially if ranges are accepted.

@Greg Marr, nice implementation. Notice your final example using the proposed lambda syntax could be a parameter overload to the small example I gave. Had we focused on making lambdas and the std algorithms more terse for C++11 rather than going with range-based for, the OP proposal would be very different. It would be asking for a library extension rather than a language one.

I believe Herb Sutter mentions in his talk, "Lambdas, Lambdas Everywhere", that he would have preferred a concise std::for_each() syntax over range-based for. No idea if he still feels that way, but this proposal seems to be a good example of the consequences.