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

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

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

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

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

struct User{
    string name;
    int age;
};
Send(Json(User("Alex", 111)));

#include <boost/fusion/include/define_struct.hpp>
#include <boost/fusion/algorithm.hpp>
#include <boost/functional/hash.hpp>
#include <iostream>
#include <string>

BOOST_FUSION_DEFINE_STRUCT
(
    (), Widget,
    (int, field1)
    (std::string, field2)
)

struct Hasher
{
    template<typename T>
    size_t operator()(size_t hash, T x)
    {
        boost::hash_combine(hash, x);
        return hash;
    }
};

template<typename Struct>
size_t hash_it(const Struct &x)
{
    return boost::fusion::fold(x, size_t(0), Hasher{});
}

int main()
{
    Widget y, x = {1, "1"};
    y.field1 = 2;
    y.field2 = "2";
    std::cout << hash_it(x) << " " << hash_it(y) << std::endl;
}

// пусть у нас есть вот такое апи
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();
}

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

DIR c:\data\docs | SORT /+39

Get-ChildItem C:\Scripts | Where-Object {$_.Length -gt 200KB} | Sort-Object Length

struct Mul {
  template<class X, class Y>auto operator()(X x, Y y) -> JUST_RETURN(x*y)
};
template<class X, class Y>auto operator*(X x, Y y) -> JUST_RETURN(bind(Mul(), x, y))

#include <functional>
#include <iostream>
#define JUST_RETURN(...) decltype( __VA_ARGS__ ) { return __VA_ARGS__; }
using namespace std;
using namespace std::placeholders;

struct Mul {
  template<class X, class Y>auto operator()(X x, Y y) const -> JUST_RETURN(x*y)
};
template<class X, class Y>auto operator*(X x, Y y) -> JUST_RETURN(bind(Mul(), x, y))

int main()
{
  cout << ( 9 * _1)(5)          << endl; // 45
  cout << (_1 *  8)(5)          << endl; // 40
  cout << (_1 * _1)(5)          << endl; // 25
  cout << (_1 * _2)(5,6)        << endl; // 30
  cout << (_1 * _2 * _3)(5,6,7) << endl; // 210
  cout << ( 9 * _2)(5,6)        << endl; // 54 (первый аргумент нафиг)
}

ComplexFunction(input_stream);//блокирует исполнение ui потока, пока не обработает все входные данные.

async_code(
    ComplexFunction(async_stream(input_stream));
)

EP>>>std::getline тут стандартная, не модифицированная. Точно также можно протащить yield и через любую другую функцию

    Task task;
    while(!finished)
    {
        main_tasks.pop(task);
        task();
    }

EP>>>>>При этом код использующий этот поток не поменяется, а в случае с C# await — нужно будет патчить весь call-stack

EP>>>С такими же рассуждениями можно прийти к мысли что и yield, и await/async не нужны

EP>Ну ты говоришь что преобразование синхронного кода в асинхронный это механическая операция. Так и преобразование кода с await/yield — точно такая же механическая операция

EP>Слушай, ну если ты не нацелен на конструктив, давай прекратим, ок? По второй ссылке Boost.Asio — самое что ни на есть асинхронное I/O, с тем самым IOCP под капотом

EP>>>Ты мне предлагаешь реализовать свои обвёртки поверх голого IOCP? Зачем?

EP>Подожди, то есть ты думаешь что для C++ нет библиотек асинхронным API

EP>Детский сад — для того чтобы пользоваться библиотекой знать её код не обязательно. В нормальных библиотеках есть чётко определённый интерфес

EP>Это привязка не к устройству, а к интерфейсу

mixin template ImplementGetSheeshCode() { 
    size_t GetSheeshCode() // эта функция станет членом класса
    {
        alias T = typeof(this);
        size_t h = 123;        
        foreach(m; __traits(allMembers, T)) // проходим по полям; такой foreach будет раскрыт, цикла не останется
            static if (m!="Monitor") {             
                static if (isIntegral!(typeof(__traits(getMember, T, m))))
                    h ^= __traits(getMember, T, m);
                else static if (__traits(hasMember, typeof(__traits(getMember, T, m)), "toHash"))
                    h ^= __traits(getMember, T, m).toHash;
            }            
        return h;
    }
}

class A { // используем МП прямо там же, где только что определили
    int Field1;
    string Field2;

    mixin ImplementGetSheeshCode; // не атрибут, но тоже одна строчка
}

void main(string[] argv)
{
    auto a = new A;
    writeln(a.GetSheeshCode());
}

EP>Те функции которые работают сокетами и т.п. — обычно thread-safe (например хоть urllib2.urlopen(url).read() из примера выше), если же нет — то об этом сказано в документации/интерфейсе

// Вот код, с которым все шоколадно в синхронном однопоточном коде
value = read()
write(next(value))

// а вот однопоточныый вариант, но асинхронный
нить 1 value = read()
нить 2 value = read()
нить 2 write(next(value)) 
нить 1 write(next(value)) // нарушение инварианта

// и вот
нить 1 value = read()
нить 2 value = read()
нить 1 write(next(value))
нить 2 write(next(value)) // нарушение инварианта

lock(_syncroot){
   value = read()
   write(next(value))
}

EP>Где

EP>>Взять например те же ranges — они проигрывают итераторам по производительности by-design

EP>>>Я вот не пойму — откуда у программистов не пишущих на C++ к нему такая злость/зависть/etc?

И внезапно, полный код выглядит на порядок чище чем в D и Nemerle.

EP>В большинстве кода нет ничего мета*, только потому, что и без него всё хорошо

EP>Если ограничится одной платформой, как делают некоторые языки, например .NET-ом, а-ля C++CLI/CX — то ABI получается что есть

EP>В ISO C++11 есть интерфейс для GC — но он вообще не популярен, что скорее говорит об востребованности

G>>await Dispatcher.RunTask(() => ComplexFunction(input_stream))
G>>

_>Это не то, это обычная синхронная работа ComplexFunction (блокирующая ui на время ожидания прихода всех данных), только отложенная на потом. В этом никакого особого смысла нет. А нам надо чтобы ComplexFunction отдавал управление, когда во входном потоке нет данных. Как видно на C++ это делается очень просто...

await Dispatcher.RunTask(async () => ComplexFunction(await input_stream));

void Echo(Stream s)
{
    var buf = new byte[256];
    while(true)
    {
        var len = s.Read(buf,0,buf.Lenght);
        s.Write(bof,0,len);
    }
}

async void Echo(Stream s)
{
    var buf = new byte[256];
    while(true)
    {
        var len = await s.ReadAsync(buf,0,buf.Lenght);
        await s.WriteAsync(bof,0,len);
    }
}

EP>>std::getline тут стандартная, не модифицированная. Точно также можно протащить yield и через любую другую функцию

int bar(int i)
{
    // await is not limited by "one level" as in C#
    auto result = await async([i]{ return reschedule(), i*100; });
    return result + i*10;
}

int foo(int i)
{
    cout << i << ":\tbegin" << endl;
    // instead of async can be any future with .then
    cout << await async([i]{ return reschedule(), i*10; }) << ":\tbody" << endl;
    cout << bar(i) << ":\tend" << endl;
    return i*1000;
}

void async_user_handler()
{
    vector<future<int>> fs;

    // instead of `async` at function signature, `asynchronous` should be
    // used at the call place:
    for(auto i=0; i!=5; ++i)
        fs.push_back( asynchronous([i]{ return foo(i+1); }) );

    for(auto &&f : fs)
        cout << await f << ":\tafter end" << endl;
}

EP>>>>При этом код использующий этот поток не поменяется, а в случае с C# await — нужно будет патчить весь call-stack

EP>>С такими же рассуждениями можно прийти к мысли что и yield, и await/async не нужны

EP>>Ты мне предлагаешь реализовать свои обвёртки поверх голого IOCP? Зачем?

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

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!

const(int)* p;
int* q = cast(int*)p;
*q = 3;   // undefined behavior

// D:
//ptr to const ptr to const int
const(int*)* p;
//const ptr to const ptr to const int
const int** p;
**p = 3; // error

// C:
//ptr to const ptr to const int
const int *const *p;

auto a1 = "just a string";
auto a2 = r"raw string\n\r";
auto a3 = `raw string\n\r`;

auto а5 = q"/test/eee/"; // Error.
auto a6 = q"[]]"; // Error.
auto a7 = q"[[]]"; // OK, a7 = "[]".

auto a1 = q"EOS
Test string
EOS";

auto a1 = q"EOS
  Test string
  EOS";

R"delimiter(The String Data \ Stuff " )delimiter"

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

R r;
if (r.empty) {}
r.popFront();
auto element = r.front;
auto copy = r.save();

R r1, r2;

I i1, i2;
// [i1, i2) - все элементы между, включая первый

inout(string)* opBinaryRight(string op)(string key) inout if(op == "in") {...}