Хорошо известный D-разработчик Андрей Александреску внёс в репозиторий Facebook первые 5112 строк кода на языке D, так что теперь гигант социальных сетей может сказать, что "использует язык D в серийном производстве". Язык был разработан Уолтером Брайтом, главным разработчиком компилятора C++ — "Zortech C++".

Александреску подтвердил, что проект, что называется, в "ежедневном, тяжёлом использовании" центром Facebook и в сравнении с оригинальной С++ версией, команда отметила множество выйгрышей во всех аспектах, включая размер исходников, скорость компилляции и скорость исполнения.

"D однозначно больше не может затмеваться С++, потому что превосходит не только слабые, но и сильные стороны С++. Касательно языка Go, вряд ли он будет преемником Си, т.к. не охватывает всего того, что Си умеет и что востребовано в некоторых системах — произвольный доступ к памяти, ручное управление памятью, да к тому же плохо взаимодействует с Си", — сказал Александреску.

*здесь пропущены характеристики Ди — всё и даже больше, чем всё есть на оффсайте*

Уолтер Брайт прокомментировал новость как "начало первого сражения, предвещающего конец Средиземья и наступление Эры D" (видимо, отнесение к Толкиену и его Кольцам, прим. пер.)
Другие D-разработчики, такие как J. M. Davis, выразились более прозаично: "Это не означает, что D типа захватил мир программирования, но это хорошо показывает, что язык D взрослеет и реальные компании хотят его реально использовать".

void sort(RandomAccessRange &x)
{
   //...
}
void sort(BidirectionalRange &x)
{
   //...
}

auto result = r;
for (;;)
{
    for (;;)
    {
        if (r.empty) return result;
        if (!pred(r.front)) break;
        r.popFront();
        result.popFront();
    }
    for (;;)
    {
        if (pred(r.back)) break;
        r.popBack();
        if (r.empty) return result;
    }
    swap(r.front, r.back);
    r.popFront();
    result.popFront();
    r.popBack();
}

while (true)
{
    while (true)
        if (first == last) return first;
        else if (pred(*first)) ++first;
        else break;
    --last;
    while (true)
        if (first == last) return first;
        else if (!pred(*last)) --last;
        else break;
    iter_swap(first, last);
    ++first;
}

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

D is a general purpose systems and applications programming language. It is a high level language, but retains the ability to write high performance code and interface directly with the operating system API's and with hardware.

Q: Are there plans to use D in Facebook?
A: Not for the time being.

template<typename T>
concept bool Equality_comparable()
{
    return requires(T a, T b)
    {
        bool = {a == b};
        bool = {a != b};
    };
}

Facebook на три часа оказался недоступен по всему миру
Пользователи Facebook по всему миру жаловались на невозможность опубликовать статус и обновить ленту новостей. При попытке захода в соцсеть отображалось сообщение о закрытии сервиса на временные технические работы

Как сообщили официальные представители Facebook в России, ошибка была вызвана техническим сбоем сети.

"Сегодня утром во время технического обслуживания сети произошла ошибка, не позволявшая некоторым пользователям публиковать статусы и комментировать на Facebook в течение короткого периода времени. Мы быстро решили вопрос и снова работаем на 100%. Приносим извинения за любые неудобства, вызванные сбоем."

В справке Facebook поясняется, что такие проблемы обычно наблюдаются у пользователей, чей аккаунт хранится в базе данных, улучшением которой в данный момент занимается компания.

int opApply(int delegate(ref Type [, ...]) dg);
int opApplyReverse(int delegate(ref Type [, ...]) dg);

foreach(x; tuple_like)
{
    // ...
}
//versus
for_each(tuple_like, [&](auto x)
{
    // ...
});

// runtime
for_each(range, [](auto x)
{

});
// compile-time
for_each(tuple_like, [](auto x)
{

});

void advance(RandomAccessIterator it, Distance n);

E>Ну бывают же не только пары итераторов, но и тройки, скажем, или, наоборот, одинокие итераторы, например итератор элемента std::list'а...

template <typename I> // I models Linked Iterator
I reverse_append(I first, I limit, I result)
{
    while (first != limit) {
        I old_successor = successor(first);
        set_successor(first, result);
        result = first;
        first = old_successor;
    }
    return result;
}

E>Ну бывают же не только пары итераторов, но и тройки, скажем, или, наоборот, одинокие итераторы, например итератор элемента std::list'а...

interface OnePassRange {
   bool empty();
   Ref<T> front();
   void popFront();
}

E>>Ну бывают же не только пары итераторов, но и тройки, скажем, или, наоборот, одинокие итераторы, например итератор элемента std::list'а...

Another example of an iterator-based design that's not easy to replicate with ranges is Boost Multi-Index. (Thanks Emil Dotchevski for pointing that out during my talk. (Marshall Clow promised the video will be available Real Real Soon Now(tm).)) In Multi-Index, indexes store iterators; storing ranges would often waste twice the space for little
or no benefit.

FR>interface OnePassRange {
FR>   bool empty();
FR>   Ref<T> front();
FR>   void popFront();
FR>}
FR>

Another weakness I noticed is visible when translating STL algorithms that return one iterator, such as find, which has this signature:

It find(It b, It e, E value)

where It is a one-pass iterator type and E is the type referenced by the iterator. STL's find returns the first iterator iter between b and (excluding) e that satisfies *iter == value. Once that iterator is returned, you can combine it with b to obtain the range before value, or with e to obtain the range after value.

Ranges lack such capabilities. The range-based find has this signature:

Range find(Range r, E value)

It consumes from r until it finds value and returns what's left of r. This means that you get access to the portion after the found value, but not before.

Fortunately, this problem is easily solved by defining a new range type, Until. Until is a range that takes another range r and a value v, starts at the beginning of r, and ends just before r.front() == v (or at the natural end of r if v is not to be found). Lazy computation for the win!

EP>foreach(x; tuple_like)
EP>{
EP>    // ...
EP>}
EP>//versus
EP>for_each(tuple_like, [&](auto x)
EP>{
EP>    // ...
EP>});
EP>

EP>Имхо, ничего страшного

import std.stdio;

void print_type(A...)(A a)
{
    foreach(T; A)
        writeln(typeid(T));
}

void main()
{
print_type(1, 2.0, "3");
}

struct PrintType
{
    template<typename T> void operator()(T) const
    {
        std::cout << typeid(T).name() << std::endl;
    }
};

template<typename ...Ts>
void foo(Ts...)
{
    using namespace boost::mpl;
    for_each<vector<Ts...>>(PrintType());
}

template<typename ...Ts>
void foo(Ts...)
{
    using namespace boost::mpl;
    for_each<vector<Ts...>>([](auto x)
    {
        std::cout << typeid(decltype(x)).name() << std::endl;
    });
}

void print_type(A...)(A a)
{
    foreach(T; A)
        writeln(typeid(T));
}
// versus
template<typename ...Ts> void foo(Ts...)
{
    for_each<Ts...>([](auto x)
    {
        writeln(type_name(decltype(x)));
    });
}

import std.stdio;
import std.range;
import std.algorithm;

void main()
{
iota(0, 10).map!(x => x *x).filter!(x => x % 2).writeln;
}

FR>import std.stdio;
FR>import std.range;
FR>import std.algorithm;

FR>void main()
FR>{
FR>iota(0, 10).map!(x => x *x).filter!(x => x % 2).writeln;
FR>}
FR>

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

FR>void main()
FR>{
FR>iota(0, 10).map!(x => x *x).filter!(x => x % 2).writeln;
FR>}
FR>

int main()
{
    for(auto x: irange(0, 10) | transformed( _1 * _1 ) | filtered(_1 % 2))
        cout << x << endl;
}

FR>в то время когда у Алекандреску с его rangeманией была совсем другая любимая игрушка

FR>>>По моему у тебя идея фикс "новые range бесплатно" ,

EP>>Не только у меня — смотри выше что пишет A.A. про std::find — чтобы получить первую часть, нужно делать реализовывать новый тип range — Until, в то время как в STL он действительно получается бесплатно: [first, find(first, last, x))

FR>Думаю, пока как выкрутится

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

EP>>>Не только у меня — смотри выше что пишет A.A. про std::find — чтобы получить первую часть, нужно делать реализовывать новый тип range — Until, в то время как в STL он действительно получается бесплатно: [first, find(first, last, x))

FR>>Думаю, пока как выкрутится

EP>

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

auto firstPart(R,T)(R xs, T x)
{
    auto n = xs.save.countUntil(x);
    if (n < 0) return xs;
    return xs.takeExactly(n);
}

EP>Это действительно круто(так же круто как и mixins), но эта фича слабо связанна с концепциям

static if (__traits(compiles, x + 1))
    writeln("number");
else
    writeln("owl");

import std.stdio;
import std.array;

int count(Range)(Range r)
{
int result = 0;
for(; !r.empty; r.popFront())
    ++result;
return result;
}

void main()
{
writeln(count([1, 2, 3]));
}

count000.d(7): Error: no property 'empty' for type 'int[]'
count000.d(7): Error: no property 'popFront' for type 'int[]'
count000.d(14): Error: template instance count000.count!(int[]) error instantiating

FR>>в то время когда у Алекандреску с его rangeманией была совсем другая любимая игрушка

FR>>Думаю, пока как выкрутится

EP>

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

Range find(Range, T)(Range r, T t)
{
while(!r.empty && r.front != t)
    r.popFront();
return r;
}

void test(R)(R xs) if (isRandomAccessRange!R)
{...}

void test(R)(R xs) if (isForwardRange!R)
{...}

EP>>

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

DM>auto firstPart(R,T)(R xs, T x)
DM>{
DM>    auto n = xs.save.countUntil(x);
DM>    if (n < 0) return xs;
DM>    return xs.takeExactly(n);
DM>}
DM>

auto it = find(first, last, x);
process_first_half(first, it);
process_second_half(it, last);

FR>count000.d(7): Error: no property 'empty' for type 'int[]'
FR>count000.d(7): Error: no property 'popFront' for type 'int[]'
FR>count000.d(14): Error: template instance count000.count!(int[]) error instantiating
FR>

FR>>>в то время когда у Алекандреску с его rangeманией была совсем другая любимая игрушка

FR>Ну "вот и выросло поколение" С++ конечно, как раз наверно писал свое "Современное проектирование на C++".

FR>Range find(Range, T)(Range r, T t)
FR>{
FR>while(!r.empty && r.front != t)
FR>    r.popFront();
FR>return r;
FR>}
FR>

EP>По факту D Range нормально подходит только для SinglePass.

irange(0, 10) | transformed( _1 * _1 ) | filtered(_1 % 2)

EP>>Это действительно круто(так же круто как и mixins), но эта фича слабо связанна с концепциям

void test(R)(R xs) if (isRandomAccessRange!R)
{...}

void test(R)(R xs) if (isForwardRange!R)
{...}

DM>static if (__traits(compiles, x + 1))
DM>    writeln("number");
DM>else
DM>    writeln("owl");    
DM>

static if (__traits(compiles, some_function_with_static_assert_inside() ))
// ..

EP>foreach(x; tuple_like)
EP>{
EP>    // ...
EP>}
EP>//versus
EP>for_each(tuple_like, [&](auto x)
EP>{
EP>    // ...
EP>});
EP>

EP>Имхо, ничего страшного

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

EP>static if (__traits(compiles, some_function_with_static_assert_inside() ))
EP>// ..
EP>

bool something(T)(T x)
{
    static assert(is(T==bool));
    return true;
}

void main(string[] argv)
{
    static if (__traits(compiles, something(2+3)))
        writeln("yes");
    else 
        writeln("no");
}

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();
}