-concepts (a way to write constraints for templates that lets us get way better error messages, overloading, and general template usability)
-advanced concurrency libraries (e.g., thread pools and reader-writer locks)
-garbage collection

Probably the biggest thing we did at this meeting was to choose time over scope: We decided that we can't ship C++0x without concepts, but we can and will ship without some or all of the other two.

What we voted into draft C++0x

Here is a list of the main features we voted into the C++0x working draft at this meeting, with links to the relevant papers to read for more information.

nullptr (N2431)
...

Explicit conversion operators (N2437 and N2434)
...

Concurrency memory model (N2429)

As I wrote in "The Free Lunch Is Over", chip designers and compiler writers "are under so much pressure to deliver ever-faster CPUs that they’ll risk changing the meaning of your program, and possibly break it, in order to make it run faster." This only gets worse in the presence of multiple cores and processors.

A memory model is probably of the lowest-level treaty between programmers and would-be optimizers, and fundamental for any higher-level concurrency work. Quoting from my memory model paper: "A memory model describes (a) how memory reads and writes may be executed by a processor relative to their program order, and (b) how writes by one processor may become visible to other processors. Both aspects affect the valid optimizations that can be performed by compilers, physical processors, and caches, and therefore a key role of the memory model is to define the tradeoff between programmability (stronger guarantees for programmers) and performance (greater flexibility for reordering program memory operations)."

Atomic types (N2427)

Closely related to the memory model is the feature of atomic types that are safe to use concurrently without locks. In C++0x, they will be spelled "atomic<T>". Here's a sample of how to use them for correct (yes, correct!) Double-Checked Locking in the implementation of a singleton Widget:

atomic<Widget*> Widget::pInstance = 0;

Widget* Widget::Instance() {
if( pInstance == 0 ) { // 1: first check
lock<mutex> hold( mutW ); // 2: acquire lock (crit sec enter)
if( pInstance == 0 ) { // 3: second check
pInstance = new Widget(); // 4: create and assign
}
} // 5: release lock
return pInstance; // 6: return pointer
}

Threading library (N2447)

You might have noticed that the above example used a lock<mutex>. Those are now in the draft standard too. C++0x now includes support for threads, various flavors of mutexes and locks, and condition variables, along with some other useful concurrency helpers like an efficient and portable std::call_once.

HANDLE CreateEvent(
  LPSECURITY_ATTRIBUTES lpEventAttributes, 
  BOOL bManualReset, 
  BOOL bInitialState, 
  LPTSTR lpName 
);

bManualReset
[in] Boolean that specifies whether a manual-reset or auto-reset event object is created. If TRUE, then you must use the ResetEvent function to manually reset the state to nonsignaled. If FALSE, the system automatically resets the state to nonsignaled after a single waiting thread has been released.

using System;
using System.Threading;

namespace SemaphoreProbe
{
    // обёртка над виндовозным
    internal class ClassicSemaphore
    {
        private Semaphore sem;

        public ClassicSemaphore(int max) { sem = new Semaphore(max, max); }
        public void Enter() { sem.WaitOne(); }
        public void Exit() { sem.Release(); }
        // Dispose() - лень 
    }

    // целевой класс
    internal class Event {
        private ClassicSemaphore sem = new ClassicSemaphore(1);

        // семафор-наоборот
        public Event() { sem.Enter(); }
        public virtual void Wait() { Reset(); Set(); }
        public void Set() { sem.Exit(); }
        public void Reset() { sem.Enter(); }
    }

    internal class AutoresetEvent : Event {
        public override void Wait() { Reset(); }
    }

    // демонстрация
    internal class Program {
        private static volatile Event ev1;
        private static volatile bool finish = false;

        private static void Main() {
            Console.WriteLine("Autoreset Event Test:\n");
            ev1 = new AutoresetEvent();

            for (int i = 0; i < 10; i++)
                new Thread(ThreadProcAutoreset).Start();

            for (int i = 0; i < 10; i++) {
                Thread.Sleep(1);
                ev1.Set();
            }

            finish = true;
            for (int i = 0; i < 10; i++)
                ev1.Set();
            finish = false;

            Console.WriteLine("\nManual Reset Event Test:");
            ev1 = new Event();

            for (int i = 0; i < 10; i++)
                new Thread(ThreadProcManual).Start();

            for (int i = 0; i < 5; i++) {
                Console.Write("\nSignaled: ");
                ev1.Set();
                Thread.Sleep(1);
                ev1.Reset();
                Console.WriteLine();
            }

            finish = true;
            ev1.Set();
        }

        private static void ThreadProcAutoreset()
        {
            while (!finish) {
                ev1.Wait();
                if (!finish)
                    Console.WriteLine("Autoreset #" + Thread.CurrentThread.ManagedThreadId);
            }
        }

        private static void ThreadProcManual()
        {
            while (!finish) {
                ev1.Wait();
                if (!finish)
                    Console.Write("#" + Thread.CurrentThread.ManagedThreadId + " ");
            }
        }
    }
}

V>Точно сильно?

public virtual void Wait() { Reset(); Set(); }

Autoreset Event Test:

Autoreset #4
Autoreset #5
Autoreset #4
Autoreset #12
Autoreset #4
Autoreset #12
Autoreset #4
Autoreset #12
Autoreset #4

Unhandled Exception: System.Threading.SemaphoreFullException: Adding the given count to the semaphore would cause it to exceed its maximum count.
   at System.Threading.Semaphore.Release(Int32 releaseCount)
   at System.Threading.Semaphore.Release()
   at SemaphoreProbe.ClassicSemaphore.Exit() in c:\work\ConsoleApplication5\Program.cs:line 13
   at SemaphoreProbe.Event.Set() in c:\work\ConsoleApplication5\Program.cs:line 25
   at SemaphoreProbe.Program.Main() in c:\work\ConsoleApplication5\Program.cs:line 56

    internal class Event
    {
        private System.Threading.EventWaitHandle event_;
        public Event()
        {
            event_ = Create();
        }

        protected virtual System.Threading.EventWaitHandle Create()
        {
            return new System.Threading.ManualResetEvent(true);
        }

        public virtual void Wait() { event_.WaitOne(); }
        public void Set() { event_.Set(); }
        public void Reset() { event_.Reset(); }
    }

    internal class AutoresetEvent : Event
    {
        protected override System.Threading.EventWaitHandle Create()
        {
            return new System.Threading.AutoResetEvent(true);
        }
    }

        private static void ThreadProcAutoreset()
        {
            ev1.Wait();
            Console.WriteLine("Autoreset #" + Thread.CurrentThread.ManagedThreadId);
        }

Autoreset Event Test:

Autoreset #3
Autoreset #5
Autoreset #4
Autoreset #7
Autoreset #9
Autoreset #8
Autoreset #10
Autoreset #12
Autoreset #11
Autoreset #6

Manual Reset Event Test:
#13 #13 #13 #13 #13 #13 #13 #13 #13 #13 #13 #13 #13 #14 #13 #13 #14 #14 #14 #14 #14 #13 #15 #15 #14 #14 #14 #14 #14 #14 #14 #14 #14 #16 #16 #16 #16 #13 #13 #16
 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #18 #18 #16 #16 #18 #18 #18 #14 #14 #14 #16 #14 #1
4 #16 #16 #14 #14 #16 #16 #14 #14 #16 #16 #16 #16 #16 #16 #16 #16 #16 #17 #17 #17 #17 #17 #17 #14 #14 #14 #14 #17 #17 #17 #13 #13 #14 #14 #14 #14 #13 #13 #13 #
13 #13 #14 #14 #14 #14 #14 #14 #14 #14 #16 #16 #16 #18 #18 #18 #14 #14 #18 #18 #14 #14 #18 #18 #14 #14 #14 #14 #14 #14 #14 #14 #14 #13 #13 #16 #16 #16 #16 #16
#16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #16 #19 #19 #19 #19 #19 #19 #19 #19 #16 #19 #19 #16
 #16 #16 #16 #16 #16 #19 #19 #19 #20 #19 #19 #20 #20 #20 #20 #20 #20 #18 #15 #15 #15 #15 #14 #14 #14 #14 #14 #15 #15 #15 #16 #16 #16 #16 #16 #15 #15 #17 #17 #1
7 #17 #16 #16 #16 #16 #17 #17 #17 #17 #20 #20 #20 #20 #20 #20 #17 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #
20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #21 #21 #21 #14 #14 #14 #14 #22 #22 #22 #22 #22 #22 #22 #16 #16 #22 #22 #22 #22 #22 #22 #22 #22 #17 #17 #17
Signaled: #17 #16 #18 #18 #18 #18 #21 #21 #21 #21 #21 #16 #21 #21 #16 #16 #16 #16 #21 #21 #16 #16 #16 #13 #13 #13 #13 #13 #22 #13 #13 #22 #22 #22 #22 #13 #13 #
22 #22 #22 #22 #22 #16 #17 #14 #18

Signaled: #22 #22 #22 #22 #22 #22 #22 #22 #20

Signaled: #21 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #21 #20 #21 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #21 #21 #14 #20 #13 #
19 #16 #15

Signaled: #21 #21 #21 #21 #14 #19 #14 #19 #14 #14 #19 #14 #14 #14 #20 #14 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20 #20

Signaled: #20 #20 #20 #18 #18 #18 #18 #18 #18 #18 #18 #22 #18 #19 #18 #18 #18 #18 #18 #18 #19 #19 #19 #14 #14
#19 #16 #20 #13 #22 #17 #15 #18 #21

# memory model
# atomics library

В теории любой примитив синхронизации можно выразить через любой другой примитив синхронизации.
Но на практике так никто не делает ибо тормозит.
А чтобы не тормозило каждый примитив синхронизации выпиливают под конкретную железку.

def ts = typer.TypeExpr(start);        
def tyVar = ts.Type;
def hint = tyVar.Hint;        
def startTypeInfo = hint.Value.TypeInfo;        
def endTypeInfo = typer.TypeExpr(end).Type.Hint.Value.TypeInfo;
def endType = endTypeInfo.SystemType;

template<typename T>
void f(T t1, T t2)
{
  auto R = t1 + t2;
  //...
}

FR>Вот тут http://www.cminusminus.org/rsync/dist/lua-ml-20071123.tar.gz лежит интерпретатор Lua 2.5 написанный на Ocaml, тут он же http://www.lua.org/ftp/lua-2.5.tar.gz на си, и почему то сишная версия поменьше в размерах

...Once we have [[Map]], we can provide a mapping between a Lua name like
[[Pair.mk]] and its {\ocaml} implementation. The [[register_module]]
function takes a list of (name, value) pairs, where a value can be a
function. The conversion between the interpreter's internal
representation and our's is provided by a clever infix function [[**->]]
that makes the conversion function look like a function type. The
[[Map]] module is here essential to name the user-defined argument
types. 

<<register [[Pair]]>>=    
C.register_module "Pair"
    [ "mk", V.efunc (V.value **-> V.value **->> Map.pair) Pair.mk
    ; "fst",V.efunc (Map.pair **->> V.value)              Pair.fst
    ; "snd",V.efunc (Map.pair **->> V.value)              Pair.snd
    ] g;
@

The registration of the [[Char]] module shows how to deal with errors in
conversions. [[Char.mk]] expects a string whose first character is used...

FR>Я заглядывал и показалось что что-то не так

$ for i in luaparser.mli luaparser.ml luaparsex.mli luaparsex.ml luascanner.ml ; do mv $i $i.auto ; done

$  wc -l *.ml luascanner.mll luaparsex.mly
    25 bench.ml
    12 log.ml
    86 luaast.ml
   112 luabaselib.ml
    68 luacamllib.ml
   107 luaclient.ml
   142 luafloat.ml
   270 luahash.ml
   163 luaiolib.ml
   477 lualib.ml
    31 luamathlib.ml
    25 lua.ml
    49 luarun.ml
   266 luastrlib.ml
   525 luavalue.ml
    34 main.ml
   142 srcmap.ml
   361 luascanner.mll
   212 luaparsex.mly
  3107 total

$ wc -l `find . -name *.c -or -name '*.stx'` # *.stx - это исходники парсера
   300 ./src/inout.c
   319 ./src/hash.c
   191 ./src/fallback.c
   796 ./src/lua.stx
   156 ./src/func.c
    58 ./src/mem.c
   341 ./src/lex.c
   333 ./src/undump.c
  1330 ./src/opcode.c
   145 ./src/tree.c
   278 ./src/table.c
   190 ./src/luac/print.c
   105 ./src/luac/luac.c
   248 ./src/luac/dump.c
    71 ./clients/lua/lua.c
   276 ./clients/lib/old/strlib.c
   230 ./clients/lib/old/mathlib.c
   618 ./clients/lib/old/iolib.c
   573 ./clients/lib/strlib.c
   230 ./clients/lib/mathlib.c
   295 ./clients/lib/iolib.c
  7083 total

The Erlang driver API has been extended with a portable POSIX thread 
like API for multi-threading. The Erlang driver thread API provides: 
threads, mutexes, condition variables, read/write locks, and 
thread-specific data. For more information see the erl_driver(3) 
documentation.

| Call("max", [arg1, arg2]) => Math.Max(arg1.Eval(), arg2.Eval())
| Call("min", [arg1, arg2]) => Math.Min(arg1.Eval(), arg2.Eval())
| Call(_, _) => throw InvalidOperationException(this.ToString());

 case expr::Call:
     if ("max" == e.name) Math.Max(e.arg1, e.arg2);
     else if ("min" == e.name) Math.Min(e.arg1, e.arg2);
     else throw InvalidOperationException(e);

R> case expr::Call:
R>     if ("max" == e.name) Math.Max(e.arg1, e.arg2);
R>     else if ("min" == e.name) Math.Min(e.arg1, e.arg2);
R>     else throw InvalidOperationException(e);
R>

    case expr::Call:
        if ("max" == e.name && e.args.size() == 2) Math.Max(eval(e.args[0]), eval(e.args[1]));
        else if ("min" == e.name && e.args.size() == 2) Math.Min(eval(e.args[0]), eval(e.args[1]));
        else throw InvalidOperationException(e);

| Call (OpCode ("=="), [nested_cond,
    Parm where (expr = TExpr.TypeConversion(TExpr.Literal(Literal.Bool(true)), _, _))], _) =>
    emit_branch(nested_cond.expr, else_label)

R>> case expr::Call:
R>>     if ("max" == e.name) Math.Max(e.arg1, e.arg2);
R>>     else if ("min" == e.name) Math.Min(e.arg1, e.arg2);
R>>     else throw InvalidOperationException(e);
R>>

WH>    case expr::Call:
WH>        if ("max" == e.name && e.args.size() == 2) Math.Max(eval(e.args[0]), eval(e.args[1]));
WH>        else if ("min" == e.name && e.args.size() == 2) Math.Min(eval(e.args[0]), eval(e.args[1]));
WH>        else throw InvalidOperationException(e);
WH>

 case expr::Call:
     if ("max" == e.name) Math.Max(e.intArg1, e.intArg2);
     else if ("min" == e.name) Math.Min(e.intArg1, e.intArg2);
     else throw InvalidOperationException(e);

WH>| Call (OpCode ("=="), [nested_cond,
WH>    Parm where (expr = TExpr.TypeConversion(TExpr.Literal(Literal.Bool(true)), _, _))], _) =>
WH>    emit_branch(nested_cond.expr, else_label)
WH>

WH>| Call (OpCode ("=="), [nested_cond,
WH>    Parm where (expr = TExpr.TypeConversion(TExpr.Literal(Literal.Bool(true)), _, _))], _) =>
WH>    emit_branch(nested_cond.expr, else_label)
WH>

TExpr.Literal(Literal.Bool(true))

<[ true ]>

R>> case expr::Call:
R>>     if ("max" == e.name) Math.Max(e.intArg1, e.intArg2);
R>>     else if ("min" == e.name) Math.Min(e.intArg1, e.intArg2);
R>>     else throw InvalidOperationException(e);
R>>

WH>

warning: enumeration value `x3' not handled in switch

enum X {x1, x2, x3};

int main()
{
  X x = x1;
  switch (x)
  {
    case x1: break;
    case x2: break;
  }
}

R>>

R>enum X {x1, x2, x3};

R>int main()
R>{
R>  X x = x1;
R>  switch (x)
R>  {
R>    case x1: break;
R>    case x2: break;
R>  }
R>}
R>

забудешь else throw

struct BinIntCall {string name; int a1, a2;};
struct BinOp {string name; any a1, a2;};

void to_str(any e)
{
    if (double* d = any_cast(e)) cout << *d;
    else if (BinIntCall* c = any_cast(e)) cout << c->name << "(" << c->a1 << "," << c->a2 << ")";
    else if (BinOp* c = any_cast(e)) to_str(c->a1); cout << c->name; to_str(c->a2);
    else throw 0;
}

Если забуду "else throw" — компилятор предупреждает от неполных switch, отсутствии return, неопределённых виртуальных функциях.

TExpr.Literal(Literal.Bool(true))

<[ true ]>

TExpr.TypeConversion(TExpr.Literal(Literal.Bool(true)), _, _))

case expr::Call:
     if ("max" == e.name) Math.Max(e.intArg1, e.intArg2);
     else if ("min" == e.name) Math.Min(e.intArg1, e.intArg2);
     else throw InvalidOperationException(e);