I>>foreach(x; tuple_like)
I>>{
I>>    if( ля )
I>>      continue;
I>>    if( ля ля)
I>>      break;
I>>    if( ля ля ля)
I>>      return;
I>>}
I>>

FOR_EACH(x, tuple_like)
{
    if(...)
        CONTINUE;
    if(...)
        BREAK;
    if(...)
        RETURN;
}_

auto myfind(Range, T)(Range r, T t)
{
    size_t n = 0;
    auto left = r.save;
    while(!r.empty && r.front != t) {
        r.popFront();
        n++;
    }
    return tuple(left.takeExactly(n), r);
}

EP>Тут согласен — в большинстве случаев будет не заметно. Я лишь показываю насколько абстракция неудобная, даже для простых случаев

EP>>>8. У тебя возвращается либо один тип range (исходный), либо другой (то что вернёт takeExactly) — какой в итоге тип у твоего firstPart?

DM>auto myfind(Range, T)(Range r, T t)
DM>{
DM>    size_t n = 0;
DM>    auto left = r.save;
DM>    while(!r.empty && r.front != t) {
DM>        r.popFront();
DM>        n++;
DM>    }
DM>    return tuple(left.takeExactly(n), r);
DM>}
DM>

template<typename I, typename T>
I find(I first, I last, const T& x)
{
    while(first != last && *first != x)
        ++first;
    return first;
}

EP>>Тут согласен — в большинстве случаев будет не заметно. Я лишь показываю насколько абстракция неудобная, даже для простых случаев

vector<Foo> x; // ...
sort(x);

for_each(x | transformed( _1 * _1 ) | filtered(_1 % 2), ... );

*x++ = *y++;

w[x++] = z[y++];

// пусть у нас есть вот такое апи
template<class Tuple, class Predicate>
bool all(Tuple& t, Predicate p);

#define FOREACH(NAME, TUPLE, BODY) /* расставьте бэкслеши самостоятельно */
{
    bool __return = true; /* был преждевременный return */
    all( TUPLE, [&](auto NAME)->bool {
        int __break = true;
        [&]()->void {
            int __i;
            for(__i=0; __i!=1; ++__i)
                { BODY; }
            __return = false; /* return'а не было! */
            if(__i == 1) __break = false; /* break не было */
        } ();
        return !__break;
    } );
    if(__return) return;
}

#define FOREACH_RETURNABLE(NAME, TUPLE, TYPE, BODY)
{
    optional<TYPE> __retval;
    all( TUPLE, [&](auto NAME)->bool {
        int __break = true;
        __retval = [&]()->void {
            int __i;
            for(__i=0; __i!=1; ++__i)
            { BODY; } /* return Something неявно приводится к return optional<TYPE>(Something) */
            __return = false; /* return'а не было! */
            if(__i == 1) __break = false; /* break не было */
            return optional<TYPE>(); /* возвращаем пустышку */
        } ();
        return !__break;
    } );
    if(__retval) return __retval.get();
}

class A
{
  public Field1 : int;
  public Field2 : string;
}

[ImplementGetHeshCode]
class A
{
  public Field1 : int;
  public Field2 : string;
}

GetHeshCode() : int
{
  Field1 ^ Field2.GetHeshCode()
}

J>>boost::copy( irange(0,10) | transformed(_1*_1) | filtered (_1%2)
J>>           , std::ostream_iterator<int>(std::cout, "\n") )
J>>

iota(0, 10).map!(x => x *x).filter!(x => x % 2)
// versus
irange(0, 10) | transformed(_1 * _1) | filtered(_1 % 2)
// if use same names:
iota(0, 10) | map(_1 * _1) | filter(_1 % 2)

EP>Как известно, у C++ основным приоритетом является производительность.
EP>А в D спокойно могут пожертвовать производительностью ради других целей (об этом говорил A.A.). Взять например те же ranges — они проигрывают итераторам по производительности by-design

std::cout << "Hello, World!" << std::endl;