Updated readme.

schlangster · schlangster · commit d5cb1352cf80 · 2014-07-25T11:27:26.000+02:00
diff --git a/README.md b/README.md
@@ -143,45 +143,37 @@ The change propagation is handled implicitly.
 Depending on the selected concurrency policy, updates can be parallelized:
 
 ```C++
-using namespace react;
-
-
 // Sequential updating
-{
-    REACTIVE_DOMAIN(D, sequential)
-
-    auto a = MakeVar<D>(1);
-    auto b = MakeVar<D>(2);
-    auto c = MakeVar<D>(3);
+REACTIVE_DOMAIN(D, sequential)
 
-    auto x = (a + b) * c;
+VarSignalT<int> a = MakeVar<D>(1);
+VarSignalT<int> b = MakeVar<D>(2);
+VarSignalT<int> c = MakeVar<D>(3);
 
-    b <<= 20;
-}
+// Using overloaded arithmetic operators instead of MakeSignal
+SignalT<int> x = (a + b) * c;
+```
 
+```C++
 // Parallel updating
-{
-    REACTIVE_DOMAIN(D, parallel)
+REACTIVE_DOMAIN(D, parallel)
 
-    auto in = MakeVar<D>(0);
+VarSignalT<int> in = MakeVar<D>(0);
 
-    auto op1 = MakeSignal(in, [] (int in)
-    {
-        int result = in /* Costly operation #1 */;
-        return result;
-    };
-
-    auto op2 = MakeSignal(in, [] (int in)
-    {
-        int result = in /* Costly operation #2 */;
-        return result;
-    };
+SignalT<int> op1 = MakeSignal(in, [] (int in)
+{
+    int result = doCostlyOperation1(in);
+    return result;
+};
 
-    auto out = op1 + op2;
+SignalT<int> op2 = MakeSignal(in, [] (int in)
+{
+    int result = doCostlyOperation2(in);
+    return result;
+};
 
-    // op1 and op2 can be re-calculated in parallel
-    in <<= 123456789;
-}
+// op1 and op2 can be re-calculated in parallel
+SignalT<int> out = op1 + op2;
 ```
 
 ### More examples
