std::vector<std::shared_ptr<std::thread>> v(pool_size);
    std::generate(v.begin(), v.end(), [&]{ return std::shared_ptr<std::thread>(new std::thread([&]{ iosrv.run(); }), [](std::thread* t){ std::unique_ptr<std::thread> _(t); t->join(); }); });

int fib(int n)
{
    if (n < 2)
        return n;
    int x = cilk_spawn fib(n-1);
    int y = fib(n-2);
    cilk_sync;
    return x + y;
}

int fib(int n)
{
    if (n < 2)
        return n;
    auto x = std::async(fib, n-1);
    int y = fib(n-2);
    return x.get() + y;
}

auto func(arg1 val, arg2 val2)->decltype(val)
auto func(arg1 val, arg2 val2)->Traitor<decltype(arg1)>::value_type

R foo() { R r; } // "R" встречается 2 раза
R foo() { decltype(foo()) r; } // "foo" встречается 2 раза

R foo() { decltype(return) r; } // никакой избыточности

#define IMPL ...
R foo() {IMPL;}

struct Foo
{
   T x = 0;
   T w = 1; // инициализируется в конструкторе по умолчанию
};

class Foo : Bar, Buz
{
  Foo() : Bar(123), Buz(456) {}
  // versus:
  ctor() : super(123), ????(456) {}
  // хотя что мешало сделать
  ctor() : Bar(123), Buz(456)
};

template<class T> void destruct(T* t) { if(t) t->~T(); }
// делать версию с T& опасно,
// т.к. при явном указании параметров мы можем отхватить пользовательское приведение типа

// деструктор полного типа
destruct(&foo);
// деструктор базы
destruct<Bar>(&foo);
destruct((Buz*)&foo);

template<class T> class agnostic;

#define BEGIN_CLASS(K)  class K; \
                        template<> class agnostic<K> { \
                          typedef K target_type;
#define CTOR()            agnostic() { ..... }
#define CCTOR()           agnostic(const agnostic&) { ..... }
#define DTOR()            ~agnostic() { ..... }
#define ASSIGN()          agnostic& operator=(const agnostic&) { ..... }
................          ..............
#define END_CLASS(K)    }; \
                        class K : public agnostic<K> {};

KP>Вообще, с C++ интересно получается, то чуть ли не самый мало изменяемый язык из активно использующихся, то каак понесет

(pipeline::from(input_queue) |
  bind(grep, "^Error") |
  bind(vgrep, "test@example.com") |
  bind(sed, "'s/^Error:.*Message: //") |
  output_queue).run(&threadpool);

KP>Вообще, с C++ интересно получается, то чуть ли не самый мало изменяемый язык из активно использующихся, то каак понесет

void foo(int n = 0, int k = 1, int m = 2);
foo(1,/*возможности пропускать аргумент по умолчанию*/,3);

//foo.h
struct foo {
  struct doo {
  };
};

//another.h
// - форвардной декларации вложенных классов
struct foo::doo;

//для этого
class some {
  friend struct foo::doo; //теперь doo из foo друг класса some
}

KP>Вообще, с C++ интересно получается, то чуть ли не самый мало изменяемый язык из активно использующихся, то каак понесет

void foo(A, B, C)
{
    std::tuple<__arg_types__...> args{__arg_values__...};
}

как если бы это была
template<typename... __arg_types__> void foo(__arg_types__... __arg_values__);

Foo(Tag);
FooTag();

x :=: y :=: z;

w :=: x :=: y :=: z;

namespace ns {
    class foo {
       class doo {};
    };
}
class foo {};

//другой хидер

//fw
namespace ns {
  class foo;
};

class some {
  friend class foo;
  friend class ns::foo;
  //а вот с doo облом...
};

// здесь никакого форвардного обявления класса из ns
class some {
  friend class foo; //осталось как и было
  friend namespace ns class foo; // это ns::foo
  friend namespace ns class foo class doo; //это ns::foo::doo
};

cycle(a,b,c,d,e);
vs
a:=:b:=:c:=:d:=:e;

class AbraCadAbRa
{
    this()
    {}
    ~this()
    {}
}

struct Foo: CRTP<self_type>
{
    self_type();
    ~self_type();
};

for ( auto idx: {34..56} ) {}
for ( auto idx: {34,56} ) {}

parallel_for_each( irange(0,100), [&](i) a[i]=i*2 );
or
parallel_transform( irange(0,100), a, [](i) i*2 );

X>for ( auto idx: {34..56} ) {}
X>for ( auto idx: {34,56} ) {}
X>

for ( auto idx: "34..56"_range ) {}

template<typename T, typename A>
class dynarray {
   T* start_;
   T* finish_;
   static if (!is_empty<A>::value) {
      A alloc_;
   }
};

// Although may seem like an elegant alternative, the impact 
// on the class’s implementation is far less so.
// For example, how would we write a constructor?
template<typename T, typename A>
dynarray<T, A>::dynarray(size_t n, T value, const A& alloc)
   :start_(alloc.allocate(n * sizeof(T))
   ,finish_(start + n)
{
   static if (!is_empty<A>::value) {
      alloc = alloc_;
   }
}

// Every access to the allocator member must be guarded by a new static if.
// Again, this use of static if is viral.
// A viable alternative to the use of static if or more traditional means of
// implementing the empty base optimization is to use a tuple. The tuple template
// will eliminate all of the overhead of empty classes.
// The use of static if might also be used to reorder data structures for tighter
// alignment, but this is a potentially dangerous idea that could lead to bugs that
// are exceptionally difficult to diagnose and fix.
// Being a new and relatively simple-to-use new feature, static_if would 
// undoubtedly be used by many who have no need for the relatively small 
// incremental improvement in performance offered. The library writers for which such
// techniques really are important, already have the tools and skills needed.

// The static if feature is also available inside class scope. A number of possible
// applications have been presented. Below is an example of a metafunction for
// computing factorials.

template <unsigned long n>
struct factorial {
   static if (n <= 1) {
      enum : unsigned long { value = 1 };
   } else {
      enum : unsigned long { value = factorial<n - 1>::value * n };
   }
};

// This seems like a reasonable idea, but the motivating example simply moves
// the complexity from one style of idiomatic programming to another and does
// so in a way that requires a new language feature. A better solution would be
// to use constexpr functions. A significant negative consequence of that feature
// is increased confusion about how to write integer metaprograms.

I'm starting to implement some new library features voted into C++14
at the Bristol meeting and am wondering what feature check to use.

Will there be a macro like _GXX_EXPERIMENTAL_CXX1Y__ to correspond to
-std=c++1y?

Alternatively we could set the value of __cplusplus to 201400L but I'm
not sure that's strictly allowed.