From 1659bf4ce62c8f6f7050f04c771995e1676d51a5 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 30 Jul 2014 14:03:43 +0200
Subject: [PATCH 01/75] Continuation target domain defaults to source.

---
 include/react/Domain.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/react/Domain.h b/include/react/Domain.h
index 1279c3f9..7fb1ef16 100644
--- a/include/react/Domain.h
+++ b/include/react/Domain.h
@@ -145,7 +145,7 @@ class TransactionStatus
 template
 <
     typename D,
-    typename D2
+    typename D2 = D
 >
 class Continuation : public REACT_IMPL::ContinuationBase<D,D2>
 {

From 6c297aa67a443f8c3db1966f35789702a1932d52 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 30 Jul 2014 14:04:17 +0200
Subject: [PATCH 02/75] Cleaned up LifeSim benchmark a bit (it's still not
 great).

---
 benchmarks/src/BenchmarkLifeSim.h | 63 ++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 27 deletions(-)

diff --git a/benchmarks/src/BenchmarkLifeSim.h b/benchmarks/src/BenchmarkLifeSim.h
index b53856dd..1ebab386 100644
--- a/benchmarks/src/BenchmarkLifeSim.h
+++ b/benchmarks/src/BenchmarkLifeSim.h
@@ -67,6 +67,8 @@ class Time
 template <typename D>
 class Region
 {
+    Time<D>& theTime;
+
 public:
     USING_REACTIVE_DOMAIN(D)
 
@@ -83,21 +85,17 @@ class Region
 
     SignalT<int> FoodPerDay = MakeSignal(
         theTime.Season,
-        [] (int season) {
-            return season == summer ? 20 : 10;
-        });
+        calculateFoodPerDay);
 
     SignalT<int> FoodOutputPerDay = MakeSignal(
         With(FoodPerDay,AnimalCount),
-        [] (int food, int count) {
-            return count > 0 ? food/count : 0;
-        });
+        calculateFoodOutputPerDay);
 
     EventsT<int> FoodOutput = Pulse(theTime.NewDay, FoodOutputPerDay);
 
     Region(Time<D>& time, int x, int y) :
-        Bounds( x*10, x*10+9, y*10, y*10+9 ),
-        theTime( time )
+        theTime( time ),
+        Bounds( x*10, x*10+9, y*10, y*10+9 )
     {}
 
     PositionT Center() const
@@ -126,7 +124,16 @@ class Region
     }
 
 private:
-    Time<D>& theTime;
+    static int calculateFoodPerDay(int season)
+    {
+        return season == summer ? 20 : 10;
+    }
+
+    static int calculateFoodOutputPerDay(int food, int count)
+    {
+        return count > 0 ? food/count : 0;
+    }
+
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -138,7 +145,7 @@ class World
 public:
     USING_REACTIVE_DOMAIN(D)
 
-    vector<unique_ptr<Region<D>>>    Regions;
+    vector<unique_ptr<Region<D>>>   Regions;
 
     World(Time<D>& time, int w) :
         w_( w )
@@ -199,14 +206,7 @@ class Animal
     EventsT<Region<D>*> RegionChanged   = Monitor(NewRegion);
 
     SignalT<int>        Age             = Iterate(theTime.NewDay, 0, Incrementer<int>());
-
-    SignalT<int>        Health          = Iterate(
-        FoodReceived,
-        100,
-        [] (int food, int health) {
-            auto newHealth = health + food - 10;
-            return newHealth < 0 ? 0 : newHealth > 10000 ? 10000 : newHealth;
-        });
+    SignalT<int>        Health          = Iterate(FoodReceived, 100, calculateHealth);
 
     Animal(Time<D>& time, World<D>& world, Region<D>* initRegion, unsigned seed) :
         theTime( time ),
@@ -239,20 +239,29 @@ class Animal
                 [this] (PositionT pos) {
                     return theWorld.GetRegion(pos);
                 })
+        ),
+        regionChangeContinuation_
+        (
+            MakeContinuation(RegionChanged, With(CurrentRegion),
+                [this] (Region<D>* newRegion, Region<D>* oldRegion) {
+                    oldRegion->EnterOrLeave(leave);
+                    newRegion->EnterOrLeave(enter);
+
+                    // Change region in continuation
+                    CurrentRegion <<= newRegion;
+                })
         )
     {
         initRegion->EnterOrLeave(enter);
+    }
 
-        Observe(
-            RegionChanged,
-            With(CurrentRegion),
-            [this] (Region<D>* newRegion, Region<D>* oldRegion) {
-                oldRegion->EnterOrLeave(leave);
-                newRegion->EnterOrLeave(enter);
+private:
+    Continuation<D> regionChangeContinuation_;
 
-                // Change region in continuation
-                CurrentRegion <<= newRegion;
-            });
+    static int calculateHealth(int food, int health)
+    {
+        auto newHealth = health + food - 10;
+        return newHealth < 0 ? 0 : newHealth > 10000 ? 10000 : newHealth;
     }
 };
 

From 2c77bd7add90d688188ee4961f55d2893b899d52 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 30 Jul 2014 16:02:32 +0200
Subject: [PATCH 03/75] Examples cleanup.

---
 examples/src/BasicSynchronization.cpp |  68 ++++++++-
 examples/src/Main.cpp                 | 195 +-------------------------
 2 files changed, 69 insertions(+), 194 deletions(-)

diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index 38f05f3e..2e49be40 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -9,6 +9,7 @@
 #include "tbb/tick_count.h"
 
 #include "react/Domain.h"
+#include "react/Signal.h"
 #include "react/Event.h"
 #include "react/Observer.h"
 
@@ -37,7 +38,7 @@ namespace example1
         Sensor mySensor;
 
         Observe(mySensor.Samples, [] (int v) {
-            cout << v << std::endl;
+            cout << v << endl;
         });
 
         TransactionStatus status;
@@ -157,14 +158,79 @@ namespace example2
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Example 3 - Continuations (1)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+namespace example3
+{
+    using namespace react;
+    using namespace std;
+
+    REACTIVE_DOMAIN(D, sequential_concurrent)
+
+    class Widget
+    {
+    public:
+        USING_REACTIVE_DOMAIN(D)
+
+        VarSignalT<string>  Label1 = MakeVar<D>(string( "Change" ));;
+        VarSignalT<string>  Label2 = MakeVar<D>(string( "me!" ));;
+
+        EventSourceT<>      Reset  = MakeEventSource<D,Token>();
+
+        Widget() :
+            resetCont_
+            (
+                MakeContinuation<D>(
+                    Reset,
+                    [this] (Token) {
+                        Label1 <<= string( "Change" );
+                        Label2 <<= string( "me!" );
+                    })
+            )
+        {}
+
+    private:
+        Continuation<D> resetCont_;
+    };
+
+    void Run()
+    {
+        cout << "Example 3 - Continuations (1)" << endl;
+
+        Widget myWidget;
+        int sum = 0;
+
+        Observe(myWidget.Label1, [&] (const string& v) {
+            cout << "Label 1 changed to " << v << endl;;
+        });
+
+        Observe(myWidget.Label2, [&] (const string& v) {
+            cout << "Label 2 changed to " << v << endl;;
+        });
+
+        myWidget.Label1 <<= "Hello";
+        myWidget.Label2 <<= "world";
+
+        cout << "Resetting..." << endl;
+
+        myWidget.Reset();
+
+        cout << endl;
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Run examples
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
     example1::Run();
+
     example2::v1::Run();
     example2::v2::Run();
 
+    example3::Run();
+
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 1a8f1ee3..89f61f07 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -18,205 +18,14 @@
 using namespace std;
 using namespace react;
 
-// Defines a domain.
-// Each domain represents a separate dependency graph, managed by a dedicated propagation engine.
-// Reactives of different domains can not be combined.
-
-
-void SignalExample3()
-{
-    REACTIVE_DOMAIN(D, sequential_concurrent)
-
-    cout << "Signal Example 3" << endl;
-
-    auto src = MakeVar<D>(0);
-
-    // Input values can be manipulated imperatively in observers.
-    // Inputs are implicitly thread-safe, buffered and executed in a continuation turn.
-    // This continuation turn is queued just like a regular turn.
-    // If other turns are already queued, they are executed before the continuation.
-    auto cont = MakeContinuation(src, [&] (int v) {
-        cout << "V: " << v << endl;
-        if (v < 10)
-            src <<= v+1;
-    });
-
-    src <<= 1;
-
-    cout << endl;
-}
-
-void SignalExample4()
-{
-    REACTIVE_DOMAIN(L, sequential_concurrent, ToposortEngine)
-    REACTIVE_DOMAIN(R, sequential_concurrent, ToposortEngine)
-
-    cout << "Signal Example 4" << endl;
-
-    auto srcL = MakeVar<L>(0);
-    auto srcR = MakeVar<R>(0);
-
-    auto contL = MakeContinuation<L,R>(srcL, [&] (int v) {
-        cout << "L->R: " << v << endl;
-        if (v < 10)
-            srcR <<= v+1;
-    });
-
-    auto contR = MakeContinuation<R,L>(srcR, [&] (int v) {
-        cout << "R->L: " << v << endl;
-        if (v < 10)
-            srcL <<= v+1;
-    });
-
-    srcL <<= 1;
-    printf("End\n");
-
-    cout << endl;
-}
-
-void SignalExample5()
-{
-    REACTIVE_DOMAIN(L, sequential_concurrent, ToposortEngine)
-    REACTIVE_DOMAIN(R, sequential_concurrent, ToposortEngine)
-
-    cout << "Signal Example 5" << endl;
-
-    auto srcL = MakeVar<L>(0);
-    auto depL1 = MakeVar<L>(0);
-    auto depL2 = MakeVar<L>(0);
-    auto srcR = MakeVar<R>(0);
-
-    auto contL = MakeContinuation<L,R>(
-        Monitor(srcL),
-        With(depL1, depL2),
-        [&] (int v, int depL1, int depL2) {
-            cout << "L->R: " << v << endl;
-            if (v < 10)
-                srcR <<= v+1;
-        });
-
-    auto contR = MakeContinuation<R,L>(
-        Monitor(srcR),
-        [&] (int v) {
-            cout << "R->L: " << v << endl;
-            if (v < 10)
-                srcL <<= v+1;
-        });
-
-    srcL <<= 1;
-    printf("End\n");
-
-    cout << endl;
-}
-
 void testme()
 {
-    REACTIVE_DOMAIN(D, sequential_concurrent)
-
-    std::vector<int> results;
-
-    auto f_0 = [] (int a) -> int
-    {
-        int k = 0;
-        for (int i = 0; i<10000; i++)
-            k += i;
-        return a + k;
-    };
-
-    auto f_n = [] (int a, int b) -> int
-    {
-        int k = 0;
-        for (int i=0; i<10000; i++)
-            k += i;
-        return a + b + k;
-    };
-
-    auto n1 = MakeVar<D>(0);
-    auto n2 = n1 ->* f_0;
-    auto n3 = ((n2, n1) ->* f_n) ->* f_0;
-    auto n4 = n3 ->* f_0;
-    auto n5 = ((((n4, n3) ->* f_n), n1) ->* f_n) ->* f_0;
-    auto n6 = n5 ->* f_0;
-    auto n7 = ((n6, n5) ->* f_n) ->* f_0;
-    auto n8 = n7 ->* f_0;
-    auto n9 = ((((((n8, n7) ->* f_n), n5) ->* f_n), n1) ->* f_n) ->* f_0;
-    auto n10 = n9 ->* f_0;
-    auto n11 = ((n10, n9) ->* f_n) ->* f_0;
-    auto n12 = n11 ->* f_0;
-    auto n13 = ((((n12, n11) ->* f_n), n9) ->* f_n) ->* f_0;
-    auto n14 = n13 ->* f_0;
-    auto n15 = ((n14, n13) ->* f_n) ->* f_0;
-    auto n16 = n15 ->* f_0;
-    auto n17 = ((((((n16, n15) ->* f_n), n13) ->* f_n), n9) ->* f_n)  ->* f_0;
-
-    auto src = MakeEventSource<D,int>();
-
-    atomic<int> c( 0 );
-
-    Observe(src, [&] (int v){
-        c++;
-    });
-
-    auto x0 = tbb::tick_count::now();
-
-    TransactionStatus st;
-
-    for (int i=0; i<10000; i++)
-    {
-        AsyncTransaction<D>(st, [&,i] {
-            n1 <<= 1+i;
-        });
-    }
-
-    for (int i=0; i<10000; i++)
-    {
-        AsyncTransaction<D>(st, [&,i] {
-            n1 <<= 20000+i;
-        });
-    }
-
-    for (int i=0; i<10000; i++)
-    {
-        AsyncTransaction<D>(st, [&,i] {
-            n1 <<= 100000+i;
-        });
-    }
-
-    st.Wait();
-
-    //std::thread t3([&] {
-    //    for (int i=0; i<10000; i++)
-    //        n1 <<= 1+i;
-    //});
-
-    //std::thread t2([&] {
-    //    for (int i=0; i<10000; i++)
-    //        n1 <<= 20000+i;
-    //});
-
-    //std::thread t1([&] {
-    //    for (int i=0; i<10000; i++)
-    //        n1 <<= 100000+i;
-    //});
-
-    //t3.join();
-    //t2.join();
-    //t1.join();
-    //std::chrono::milliseconds dura( 10000 );
-    //std::this_thread::sleep_for( dura );
-
-    auto x1 = tbb::tick_count::now();
-
-    double d = (x1 - x0).seconds();
-    printf("Time %g\n", d);
-    printf("Updates %d\n", c.load());
-    printf("n1 %d\n", n1());
+    // Note: This project exists as a sandbox where I occasionally stage new examples.
+    // Currently it's empty.
 }
 
 int main()
 {
-    SignalExample3();
-    SignalExample4();
     testme();
 
 #ifdef REACT_ENABLE_LOGGING

From 7ab678dbb7fc8526412d2efd09c08c40bec81314 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 30 Jul 2014 16:02:42 +0200
Subject: [PATCH 04/75] Readme tweak.

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index a10f27b3..7285d7f1 100644
--- a/README.md
+++ b/README.md
@@ -156,7 +156,6 @@ VarSignalT<int> a = MakeVar<D>(1);
 VarSignalT<int> b = MakeVar<D>(2);
 VarSignalT<int> c = MakeVar<D>(3);
 
-// Using overloaded arithmetic operators instead of MakeSignal
 SignalT<int> x = (a + b) * c;
 ```
 

From 318b585cc9d04b23827f354178e6cfb60eaa6d44 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 30 Jul 2014 16:28:39 +0200
Subject: [PATCH 05/75] Example cleanup.

---
 examples/src/BasicSynchronization.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index 2e49be40..ec2be1c9 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -173,10 +173,10 @@ namespace example3
     public:
         USING_REACTIVE_DOMAIN(D)
 
-        VarSignalT<string>  Label1 = MakeVar<D>(string( "Change" ));;
-        VarSignalT<string>  Label2 = MakeVar<D>(string( "me!" ));;
+        VarSignalT<string>  Label1 = MakeVar<D>(string( "Change" ));
+        VarSignalT<string>  Label2 = MakeVar<D>(string( "me!" ));
 
-        EventSourceT<>      Reset  = MakeEventSource<D,Token>();
+        EventSourceT<>      Reset  = MakeEventSource<D>();
 
         Widget() :
             resetCont_
@@ -199,14 +199,13 @@ namespace example3
         cout << "Example 3 - Continuations (1)" << endl;
 
         Widget myWidget;
-        int sum = 0;
 
         Observe(myWidget.Label1, [&] (const string& v) {
-            cout << "Label 1 changed to " << v << endl;;
+            cout << "Label 1 changed to " << v << endl;
         });
 
         Observe(myWidget.Label2, [&] (const string& v) {
-            cout << "Label 2 changed to " << v << endl;;
+            cout << "Label 2 changed to " << v << endl;
         });
 
         myWidget.Label1 <<= "Hello";

From 31856896ddbc4e64d2b10f60100969d4a52578ea Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 1 Aug 2014 19:17:11 +0200
Subject: [PATCH 06/75] Changed Subystem to Console for Release profile in some
 examples.

---
 project/msvc/Example_BasicAlgorithms.vcxproj  | 1 +
 project/msvc/Example_BasicComposition.vcxproj | 1 +
 project/msvc/Example_BasicEvents.vcxproj      | 1 +
 project/msvc/Example_BasicObservers.vcxproj   | 1 +
 project/msvc/Example_BasicReactors.vcxproj    | 1 +
 project/msvc/Example_BasicSignals.vcxproj     | 1 +
 6 files changed, 6 insertions(+)

diff --git a/project/msvc/Example_BasicAlgorithms.vcxproj b/project/msvc/Example_BasicAlgorithms.vcxproj
index cd4b6e9b..eeffca5a 100644
--- a/project/msvc/Example_BasicAlgorithms.vcxproj
+++ b/project/msvc/Example_BasicAlgorithms.vcxproj
@@ -118,6 +118,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
diff --git a/project/msvc/Example_BasicComposition.vcxproj b/project/msvc/Example_BasicComposition.vcxproj
index 8b336087..01d26c88 100644
--- a/project/msvc/Example_BasicComposition.vcxproj
+++ b/project/msvc/Example_BasicComposition.vcxproj
@@ -118,6 +118,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
diff --git a/project/msvc/Example_BasicEvents.vcxproj b/project/msvc/Example_BasicEvents.vcxproj
index 2e3bad5e..d5d13295 100644
--- a/project/msvc/Example_BasicEvents.vcxproj
+++ b/project/msvc/Example_BasicEvents.vcxproj
@@ -118,6 +118,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
diff --git a/project/msvc/Example_BasicObservers.vcxproj b/project/msvc/Example_BasicObservers.vcxproj
index f99889bf..9fa37b8c 100644
--- a/project/msvc/Example_BasicObservers.vcxproj
+++ b/project/msvc/Example_BasicObservers.vcxproj
@@ -118,6 +118,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
diff --git a/project/msvc/Example_BasicReactors.vcxproj b/project/msvc/Example_BasicReactors.vcxproj
index f05f8265..07701d98 100644
--- a/project/msvc/Example_BasicReactors.vcxproj
+++ b/project/msvc/Example_BasicReactors.vcxproj
@@ -118,6 +118,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
diff --git a/project/msvc/Example_BasicSignals.vcxproj b/project/msvc/Example_BasicSignals.vcxproj
index 653861ba..e090dd8a 100644
--- a/project/msvc/Example_BasicSignals.vcxproj
+++ b/project/msvc/Example_BasicSignals.vcxproj
@@ -118,6 +118,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

From 32724f98565730f61df79a9ddf1ade97f6e21080 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 1 Aug 2014 19:20:23 +0200
Subject: [PATCH 07/75] Fixed #2.

---
 examples/src/BasicAlgorithms.cpp | 35 ++++++++++++++++++++++----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index 07907c76..22f92cfb 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -93,7 +93,7 @@ namespace example2
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 3 - Creating stateful signals (1)
+/// Example 3 - Folding event streams into signals (1)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace example3
 {
@@ -119,7 +119,7 @@ namespace example3
 
     void Run()
     {
-        cout << "Example 3 - Creating stateful signals (1)" << endl;
+        cout << "Example 3 - Folding event streams into signals (1)" << endl;
 
         Counter myCounter;
 
@@ -135,7 +135,7 @@ namespace example3
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 4 - Creating stateful signals (2)
+/// Example 4 - Folding event streams into signals (2)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace example4
 {
@@ -149,23 +149,36 @@ namespace example4
     public:
         USING_REACTIVE_DOMAIN(D)
 
-        EventSourceT<int> Input = MakeEventSource<D,int>();
+        EventSourceT<float> Input = MakeEventSource<D,float>();
 
-        SignalT<float> Average = Iterate(
+        SignalT<int> Count = Iterate(
+            Tokenize(Input),
+            0,
+            [] (Token, int oldCount) {
+                return oldCount + 1;
+            });
+
+        SignalT<float> Sum = Iterate(
             Input,
             0.0f,
-            [] (int sample, float oldAvg) {
-                return (oldAvg + sample) / 2.0f;
+            [] (float v, float sum) {
+                return v + sum;
+            });
+
+        SignalT<float> Average = MakeSignal(
+            With(Sum,Count),
+            [] (float sum, int count) {
+                return count != 0 ? sum / count : 0.0f;
             });
     };
 
     void Run()
     {
-        cout << "Example 4 - Creating stateful signals (2)" << endl;
+        cout << "Example 4 - Folding event streams into signals (2)" << endl;
 
         Sensor mySensor;
 
-        mySensor.Input << 10 << 5 << 10 << 8;
+        mySensor.Input << 10.0f << 5.0f << 10.0f << 8.0f;
 
         cout << "Average: " << mySensor.Average() << endl; // output: 3
 
@@ -174,7 +187,7 @@ namespace example4
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 5 - Creating stateful signals (3)
+/// Example 5 - Folding event streams into signals (3)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace example5
 {
@@ -210,7 +223,7 @@ namespace example5
 
     void Run()
     {
-        cout << "Example 5 - Creating stateful signals (3)" << endl;
+        cout << "Example 5 - Folding event streams into signals (3)" << endl;
 
         Counter myCounter;
 

From ccd5f37f9be70ca041ad26b332ca6825b0ad097c Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 1 Aug 2014 21:08:18 +0200
Subject: [PATCH 08/75] Comment correction.

---
 examples/src/BasicAlgorithms.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index 22f92cfb..69229ee5 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -180,7 +180,7 @@ namespace example4
 
         mySensor.Input << 10.0f << 5.0f << 10.0f << 8.0f;
 
-        cout << "Average: " << mySensor.Average() << endl; // output: 3
+        cout << "Average: " << mySensor.Average() << endl; // output: 8.25
 
         cout << endl;
     }

From 4850a6a83456823901a8f4bdbbd411252fb731a1 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sat, 2 Aug 2014 17:30:16 +0200
Subject: [PATCH 09/75] Updated readme.

---
 README.md | 53 ++++++++++++++++++-----------------------------------
 1 file changed, 18 insertions(+), 35 deletions(-)

diff --git a/README.md b/README.md
index 7285d7f1..957014de 100644
--- a/README.md
+++ b/README.md
@@ -3,12 +3,12 @@
 C++React is reactive programming library for C++11.
 
 Generally speaking, it provides abstractions to handle change propagation and data processing for a push-based event model.
-A more practical description is that it enables coordinated, multi-layered - and potentially parallel - execution of callbacks.
+A more practical description is that it enables coordinated, multi-layered - _and potentially parallel_ - execution of callbacks.
 All this happens implicitly, based on declarative definitions, with guarantees regarding
 
 - _update minimality_ - nothing is re-calculated or processed unnecessarily;
 - _glitch freedom_ - no transiently inconsistent data sets;
-- _thread safety_ - no data races for parallel execution.
+- _thread safety_ - no data races for parallel execution by avoiding side effects.
 
 The core abstractions of the library are
 
@@ -30,19 +30,17 @@ Additional features include
 [If you're interested in learning about C++React, have a look at its documentation.](http://schlangster.github.io/cpp.react/)
 
 
-## Development
+## Using the library
 
-This library is a work-in-progress and should not be considered release quality yet.
+This library is a work-in-progress. It should not be considered release quality yet and its API might still change.
 It is, however, in a perfectly usable state and has already received a fair amount of testing and tuning.
 
-
 ### Dependencies
 
 * [Intel TBB 4.2](https://www.threadingbuildingblocks.org/) (required)
 * [Google test framework](https://code.google.com/p/googletest/) (optional, to compile the unit tests)
 * [Boost 1.55.0 C++ Libraries](http://www.boost.org/) (optional, to include Reactor.h, which requires `boost::coroutine`)
 
-
 ### Compiling
 
 C++React has been tested with the following compilers:
@@ -69,20 +67,21 @@ For more details, refer to the [Build instructions](https://github.com/schlangst
 ### Signals
 
 Signals are self-updating reactive variables.
-They can be combined as expressions to create new signals, which are automatically re-calculated whenever one of their dependencies changes.
+They can be combined in expressions to create new signals, which are automatically re-calculated when their dependencies change.
 
 ```C++
 using namespace std;
 using namespace react;
 
-// Define a reactive domain that uses single-threaded, sequential updating
+// Defines a reactive domain that uses single-threaded, sequential updating
 REACTIVE_DOMAIN(D, sequential)
 
-// Define aliases for types of the given domain,
+// Defines aliases for types of the given domain,
 // e.g. using VarSignalT<X> = VarSignal<D,X>
 USING_REACTIVE_DOMAIN(D)
 
 // Two reactive variables that can be manipulated imperatively
+// to input external changes
 VarSignalT<int> width  = MakeVar<D>(1);
 VarSignalT<int> height = MakeVar<D>(2);
 
@@ -110,7 +109,7 @@ Observe(area, [] (int newValue) {
 });
 ```
 
-Overloaded operators for signal types allow to omit `MakeSignal` in this case for a more concise syntax:
+Overloaded operators for signal types allow to omit `MakeSignal` for a more concise syntax:
 ```C++
 // Lift as reactive expression - equivalent to previous example
 SignalT<int> area = width * height;
@@ -118,7 +117,8 @@ SignalT<int> area = width * height;
 
 ### Event streams
 
-Event streams represent flows of discrete values. They are first-class objects and can be merged, filtered, transformed or composed to more complex types:
+Unlike signals, event streams are not centered on changing state, but represent flows of discrete values. 
+They are first-class objects and can be merged, filtered, transformed or composed to more complex types:
 
 ```C++
 using namespace std;
@@ -128,39 +128,27 @@ REACTIVE_DOMAIN(D, sequential)
 USING_REACTIVE_DOMAIN(D)
 
 // Two event sources
-EventSourceT<Token> leftClicked  = MakeEventSource<D>();
-EventSourceT<Token> rightClicked = MakeEventSource<D>();
+EventSourceT<Token> leftClick  = MakeEventSource<D>();
+EventSourceT<Token> rightClick = MakeEventSource<D>();
 
 // Merge both event streams
-EventsT<Token> merged = leftClicked | rightClicked;
+EventsT<Token> anyClick = leftClick | rightClick;
 
 // React to events
-Observe(merged, [] (Token) {
+Observe(anyClick, [] (Token) {
     cout << "clicked!" << endl;
 });
 ```
 ```
-rightClicked.Emit(); // => clicked!
+leftClick.Emit(); // => clicked!
+rightClick.Emit(); // => clicked!
 ```
 
 ### Parallelism and concurrency
 
-The change propagation is handled implicitly.
-Depending on the selected concurrency policy, updates can be parallelized:
-
-```C++
-// Sequential updating
-REACTIVE_DOMAIN(D, sequential)
-
-VarSignalT<int> a = MakeVar<D>(1);
-VarSignalT<int> b = MakeVar<D>(2);
-VarSignalT<int> c = MakeVar<D>(3);
-
-SignalT<int> x = (a + b) * c;
-```
+When enabling it through the concurrency policy, updates are automatically parallelized:
 
 ```C++
-// Parallel updating
 REACTIVE_DOMAIN(D, parallel)
 
 VarSignalT<int> in = MakeVar<D>(0);
@@ -181,11 +169,6 @@ SignalT<int> op2 = MakeSignal(in, [] (int in)
 SignalT<int> out = op1 + op2;
 ```
 
-### More examples
-
-* [Examples](https://github.com/schlangster/cpp.react/tree/master/examples/src)
-* [Test cases](https://github.com/schlangster/cpp.react/tree/master/tests/src)
-
 ## Acknowledgements
 
 The API of C++React has been inspired by the following two research papers:

From 3b1b6bc3963893a2ed07e31383bf9cfccb84b585 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 3 Aug 2014 19:12:38 +0200
Subject: [PATCH 10/75] Fixed #3.

---
 README.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 957014de..5c27b6bc 100644
--- a/README.md
+++ b/README.md
@@ -153,17 +153,17 @@ REACTIVE_DOMAIN(D, parallel)
 
 VarSignalT<int> in = MakeVar<D>(0);
 
-SignalT<int> op1 = MakeSignal(in, [] (int in)
-{
-    int result = doCostlyOperation1(in);
-    return result;
-};
-
-SignalT<int> op2 = MakeSignal(in, [] (int in)
-{
-    int result = doCostlyOperation2(in);
-    return result;
-};
+SignalT<int> op1 = MakeSignal(in,
+    [] (int in) {
+        int result = doCostlyOperation1(in);
+        return result;
+    });
+
+SignalT<int> op2 = MakeSignal(in,
+    [] (int in) {
+        int result = doCostlyOperation2(in);
+        return result;
+    });
 
 // op1 and op2 can be re-calculated in parallel
 SignalT<int> out = op1 + op2;

From 7b6009eea952cf8b3d1894218ede6a2d2eb7a76b Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 7 Aug 2014 02:29:40 +0200
Subject: [PATCH 11/75] Misc additions to Util.h.

---
 include/react/common/Util.h | 77 +++++++++++++++++++++++++++++++------
 1 file changed, 65 insertions(+), 12 deletions(-)

diff --git a/include/react/common/Util.h b/include/react/common/Util.h
index 35e8e771..b50c005b 100644
--- a/include/react/common/Util.h
+++ b/include/react/common/Util.h
@@ -102,18 +102,29 @@ struct Identity
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 struct DontMove {};
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// DisableIfSame
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T, typename U>
+struct DisableIfSame :
+    std::enable_if<! std::is_same<
+        typename std::decay<T>::type,
+        typename std::decay<U>::type>::value> {};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// AddDummyArgWrapper
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename TArg, typename F, typename TRet, typename ... TDepValues>
 struct AddDummyArgWrapper
 {
-    // Dummy int to make sure it calls the right ctor
-    template <typename FIn>
-    AddDummyArgWrapper(int, FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
-
     AddDummyArgWrapper(const AddDummyArgWrapper& other) = default;
-    AddDummyArgWrapper(AddDummyArgWrapper&& other) : MyFunc( std::move(other.MyFunc) ) {}
+
+    AddDummyArgWrapper(AddDummyArgWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template <typename FIn, class = typename DisableIfSame<FIn,AddDummyArgWrapper>::type>
+    explicit AddDummyArgWrapper(FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
 
     TRet operator()(TArg, TDepValues& ... args)
     {
@@ -126,12 +137,15 @@ struct AddDummyArgWrapper
 template <typename TArg, typename F, typename ... TDepValues>
 struct AddDummyArgWrapper<TArg,F,void,TDepValues...>
 {
-    // Dummy int to make sure it calls the right ctor
-    template <typename FIn>
-    AddDummyArgWrapper(int, FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
-
+public:
     AddDummyArgWrapper(const AddDummyArgWrapper& other) = default;
-    AddDummyArgWrapper(AddDummyArgWrapper&& other) : MyFunc( std::move(other.MyFunc) ) {}
+
+    AddDummyArgWrapper(AddDummyArgWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template <typename FIn, class = typename DisableIfSame<FIn,AddDummyArgWrapper>::type>
+    explicit AddDummyArgWrapper(FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
 
     void operator()(TArg, TDepValues& ... args)
     {
@@ -152,8 +166,20 @@ template
 >
 struct AddDefaultReturnValueWrapper
 {
-    template <typename FIn>
-    AddDefaultReturnValueWrapper(FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
+    AddDefaultReturnValueWrapper(const AddDefaultReturnValueWrapper&) = default;
+
+    AddDefaultReturnValueWrapper(AddDefaultReturnValueWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template
+    <
+        typename FIn,
+        class = typename DisableIfSame<FIn,AddDefaultReturnValueWrapper>::type
+    >
+    explicit AddDefaultReturnValueWrapper(FIn&& func) :
+        MyFunc( std::forward<FIn>(func) )
+    {}
 
     template <typename ... TArgs>
     TRet operator()(TArgs&& ... args)
@@ -165,6 +191,33 @@ struct AddDefaultReturnValueWrapper
     F MyFunc;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// IsCallableWith
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename F,
+    typename TRet,
+    typename ... TArgs
+>
+class IsCallableWith
+{
+private:
+    using NoT = char[1];
+    using YesT = char[2];
+
+    template <typename U>
+    static YesT& check(
+        decltype( static_cast<TRet>(
+            (std::declval<U>())(std::declval<TArgs>() ...))) *);
+
+    template <typename U>
+    static NoT& check(...);
+
+public:
+    enum { value = sizeof(check<F>(nullptr)) == sizeof(YesT) };
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 // Expand args by wrapping them in a dummy function

From 12d72a5d4978aba346ee0961a02c25fa15479d00 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 7 Aug 2014 02:47:50 +0200
Subject: [PATCH 12/75] Added a new range-based signature option for event
 callbacks.

Instead of passing a function `func(E)` that is called for every event on the stream, EventRange<E>  allows to iterate them manually.
This allows client code to add node-level parallelization with parallel_for or parallel_reduce.

It's supported by existing Observe and MakeContinuation, and also by a new operation `Process`, which is a more generic form of Transform/Filter.
The signature of process callbacks is `void(EventRange<int> range, EventInserter<float> out)`. out is a back_insert_iterator.
---
 include/react/Domain.h                        |  26 ++-
 include/react/Event.h                         |  66 ++++++
 include/react/Observer.h                      |  60 +++--
 .../react/detail/graph/ContinuationNodes.h    |  45 +++-
 include/react/detail/graph/EventNodes.h       | 217 +++++++++++++++---
 include/react/detail/graph/GraphBase.h        |  24 ++
 include/react/detail/graph/ObserverNodes.h    |  74 +++---
 7 files changed, 415 insertions(+), 97 deletions(-)

diff --git a/include/react/Domain.h b/include/react/Domain.h
index 7fb1ef16..ac049438 100644
--- a/include/react/Domain.h
+++ b/include/react/Domain.h
@@ -235,10 +235,21 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&&
         "MakeContinuation requires support for concurrent input to target domain.");
 
     using REACT_IMPL::EventContinuationNode;
+    using REACT_IMPL::AddContinuationRangeWrapper;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::EventRange;
+
     using F = typename std::decay<FIn>::type;
 
+    using WrapperT =
+        typename std::conditional<
+            IsCallableWith<F,void, EventRange<E>>::value,
+            F,
+            AddContinuationRangeWrapper<E, F>
+        >::type;
+
     return Continuation<D,DOut>(
-        std::make_shared<EventContinuationNode<D,DOut,E,F>>(
+        std::make_shared<EventContinuationNode<D,DOut,E,WrapperT>>(
             flags, GetNodePtr(trigger), std::forward<FIn>(func)));
 }
 
@@ -274,8 +285,19 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger,
         "MakeContinuation requires support for concurrent input to target domain.");
 
     using REACT_IMPL::SyncedContinuationNode;
+    using REACT_IMPL::AddContinuationRangeWrapper;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::EventRange;
+
     using F = typename std::decay<FIn>::type;
 
+    using WrapperT =
+        typename std::conditional<
+            IsCallableWith<F, void, EventRange<E>, TDepValues ...>::value,
+            F,
+            AddContinuationRangeWrapper<E, F, TDepValues ...>
+        >::type;
+
     struct NodeBuilder_
     {
         NodeBuilder_(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&& func) :
@@ -288,7 +310,7 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger,
             -> Continuation<D,DOut>
         {
             return Continuation<D,DOut>(
-                std::make_shared<SyncedContinuationNode<D,DOut,E,F,TDepValues...>>(
+                std::make_shared<SyncedContinuationNode<D,DOut,E,WrapperT,TDepValues...>>(
                     MyFlags,
                     GetNodePtr(MyTrigger),
                     std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
diff --git a/include/react/Event.h b/include/react/Event.h
index 550ef5ac..e3f70f3e 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -345,6 +345,72 @@ auto Transform(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& d
         depPack.Data);
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Process
+///////////////////////////////////////////////////////////////////////////////////////////////////
+using REACT_IMPL::EventRange;
+using REACT_IMPL::EventInserter;
+
+template
+<
+    typename TOut,
+    typename D,
+    typename TIn,
+    typename FIn,
+    typename F = typename std::decay<FIn>::type
+>
+auto Process(const Events<D,TIn>& src, FIn&& func)
+    -> Events<D,TOut>
+{
+    using REACT_IMPL::EventProcessingNode;
+
+    return Events<D,TOut>(
+        std::make_shared<EventProcessingNode<D,TIn,TOut,F>>(
+            GetNodePtr(src), std::forward<FIn>(func)));
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Process - Synced
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename TOut,
+    typename D,
+    typename TIn,
+    typename FIn,
+    typename ... TDepValues
+>
+auto Process(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& depPack, FIn&& func)
+    -> Events<D,TOut>
+{
+    using REACT_IMPL::SyncedEventProcessingNode;
+
+    using F = typename std::decay<FIn>::type;
+
+    struct NodeBuilder_
+    {
+        NodeBuilder_(const Events<D,TIn>& source, FIn&& func) :
+            MySource( source ),
+            MyFunc( std::forward<FIn>(func) )
+        {}
+
+        auto operator()(const Signal<D,TDepValues>& ... deps)
+            -> Events<D,TOut>
+        {
+            return Events<D,TOut>(
+                std::make_shared<SyncedEventProcessingNode<D,TIn,TOut,F,TDepValues ...>>(
+                     GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
+        }
+
+        const Events<D,TIn>&    MySource;
+        FIn                     MyFunc;
+    };
+
+    return REACT_IMPL::apply(
+        NodeBuilder_( source, std::forward<FIn>(func) ),
+        depPack.Data);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 07d76c32..9b50fc6a 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -185,7 +185,6 @@ auto Observe(const Signal<D,S>& subject, FIn&& func)
         SignalObserverNode<D,S,F>
             >::type;
 
-
     const auto& subjectPtr = GetNodePtr(subject);
 
     std::unique_ptr<ObserverNode<D>> nodePtr( new TNode(subjectPtr, std::forward<FIn>(func)) );
@@ -212,18 +211,29 @@ auto Observe(const Events<D,E>& subject, FIn&& func)
     using REACT_IMPL::ObserverNode;
     using REACT_IMPL::EventObserverNode;
     using REACT_IMPL::AddDefaultReturnValueWrapper;
+    using REACT_IMPL::AddObserverRangeWrapper;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::EventRange;
 
     using F = typename std::decay<FIn>::type;
-    using R = typename std::result_of<FIn(E)>::type;
-    using WrapperT = AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>;
 
-    // If return value of passed function is void, add ObserverAction::next as
-    // default return value.
-    using TNode = typename std::conditional<
-        std::is_same<void,R>::value,
-        EventObserverNode<D,E,WrapperT>,
-        EventObserverNode<D,E,F>
-            >::type;
+    using WrapperT =
+        typename std::conditional<
+            IsCallableWith<F, ObserverAction, EventRange<E>>::value,
+            F,
+            typename std::conditional<
+                IsCallableWith<F, ObserverAction, E>::value,
+                AddObserverRangeWrapper<E, F>,
+                typename std::conditional<
+                    IsCallableWith<F, void, EventRange<E>>::value,
+                    AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
+                    AddObserverRangeWrapper<E,
+                        AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>>
+                >::type
+            >::type
+        >::type;
+    
+    using TNode = EventObserverNode<D,E,WrapperT>;
     
     const auto& subjectPtr = GetNodePtr(subject);
 
@@ -253,18 +263,30 @@ auto Observe(const Events<D,E>& subject,
     using REACT_IMPL::ObserverNode;
     using REACT_IMPL::SyncedObserverNode;
     using REACT_IMPL::AddDefaultReturnValueWrapper;
+    using REACT_IMPL::AddObserverRangeWrapper;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::EventRange;
 
     using F = typename std::decay<FIn>::type;
-    using R = typename std::result_of<FIn(E,TDepValues...)>::type;
-    using WrapperT = AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>;
 
-    // If return value of passed function is void, add ObserverAction::next as
-    // default return value.
-    using TNode = typename std::conditional<
-        std::is_same<void,R>::value,
-        SyncedObserverNode<D,E,WrapperT,TDepValues ...>,
-        SyncedObserverNode<D,E,F,TDepValues ...>
-            >::type;
+    using WrapperT =
+        typename std::conditional<
+            IsCallableWith<F, ObserverAction, EventRange<E>, TDepValues ...>::value,
+            F,
+            typename std::conditional<
+                IsCallableWith<F, ObserverAction, E, TDepValues ...>::value,
+                AddObserverRangeWrapper<E, F, TDepValues ...>,
+                typename std::conditional<
+                    IsCallableWith<F, void, EventRange<E>, TDepValues ...>::value,
+                    AddDefaultReturnValueWrapper<F, ObserverAction ,ObserverAction::next>,
+                    AddObserverRangeWrapper<E,
+                        AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
+                        TDepValues...>
+                >::type
+            >::type
+        >::type;
+
+    using TNode = SyncedObserverNode<D,E,WrapperT,TDepValues ...>;
 
     struct NodeBuilder_
     {
diff --git a/include/react/detail/graph/ContinuationNodes.h b/include/react/detail/graph/ContinuationNodes.h
index ab3c3cd2..c841d23f 100644
--- a/include/react/detail/graph/ContinuationNodes.h
+++ b/include/react/detail/graph/ContinuationNodes.h
@@ -30,6 +30,36 @@ class SignalNode;
 template <typename D, typename E>
 class EventStreamNode;
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// AddContinuationRangeWrapper
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E, typename F, typename ... TArgs>
+struct AddContinuationRangeWrapper
+{
+    AddContinuationRangeWrapper(const AddContinuationRangeWrapper& other) = default;
+
+    AddContinuationRangeWrapper(AddContinuationRangeWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template
+    <
+        typename FIn,
+        class = typename DisableIfSame<FIn,AddContinuationRangeWrapper>::type
+    >
+    explicit AddContinuationRangeWrapper(FIn&& func) :
+        MyFunc( std::forward<FIn>(func) )
+    {}
+
+    void operator()(EventRange<E> range, const TArgs& ... args)
+    {
+        for (const auto& e : range)
+            MyFunc(e, args ...);
+    }
+
+    F MyFunc;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ContinuationNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -171,13 +201,10 @@ class EventContinuationNode : public ContinuationNode<D>
             // Copy events and func
             [storedFunc,storedEvents] () mutable
             {
-                for (const auto& e : storedEvents)
-                    storedFunc(e);
+                storedFunc(EventRange<E>( storedEvents ));
             }
         );
 
-        TransactionFuncT cont2 = [] { return; };
-
         DomainSpecificInputManager<D>::Instance()
             .StoreContinuation(
                 DomainSpecificInputManager<DOut>::Instance(),
@@ -291,10 +318,12 @@ class SyncedContinuationNode : public ContinuationNode<D>
             // Copy events, func, value tuple (note: 2x copy)
             [storedFunc,storedEvents,storedValues] () mutable
             {
-                for (const auto& e : storedEvents)
-                {
-                    apply(EvalFunctor_( e, storedFunc ), storedValues);
-                }
+                apply(
+                    [&storedFunc,&storedEvents] (const TDepValues& ... vals)
+                    {
+                        storedFunc(EventRange<E>( storedEvents ), vals ...);
+                    },
+                    storedValues);
             }
         };
 
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 484ed997..bc4eb4b3 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -547,7 +547,7 @@ class EventFlattenNode : public EventStreamNode<D,TInner>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SycnedEventTransformNode
+/// SyncedEventTransformNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
@@ -590,22 +590,6 @@ class SyncedEventTransformNode :
 
     virtual void Tick(void* turnPtr) override
     {
-        struct EvalFunctor_
-        {
-            EvalFunctor_(const TIn& e, TFunc& f) :
-                MyEvent( e ),
-                MyFunc( f )
-            {}
-
-            TOut operator()(const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-            {
-                return MyFunc(MyEvent, args->ValueRef() ...);
-            }
-
-            const TIn&  MyEvent;
-            TFunc&      MyFunc;
-        };
-
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
@@ -617,12 +601,20 @@ class SyncedEventTransformNode :
         REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
             GetObjectId(*this), turn.Id()));
 
+        // Don't time if there is nothing to do
+        if (! source_->Events().empty())
         {// timer
             using TimerT = typename SyncedEventTransformNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, source_->Events().size() );
 
             for (const auto& e : source_->Events())
-                this->events_.push_back(apply(EvalFunctor_( e, func_ ), deps_));
+                this->events_.push_back(apply(
+                        [this, &e] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
+                        {
+                            return func_(e, args->ValueRef() ...);
+                        },
+                        deps_));
+                    
         }// ~timer
 
         REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
@@ -647,7 +639,7 @@ class SyncedEventTransformNode :
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SycnedEventFilterNode
+/// SyncedEventFilterNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
@@ -689,22 +681,6 @@ class SyncedEventFilterNode :
 
     virtual void Tick(void* turnPtr) override
     {
-        struct EvalFunctor_
-        {
-            EvalFunctor_(const E& e, TFunc& f) :
-                MyEvent( e ),
-                MyFilter( f )
-            {}
-
-            bool operator()(const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-            {
-                return MyFilter(MyEvent, args->ValueRef() ...);
-            }
-
-            const E&    MyEvent;
-            TFunc&      MyFilter;
-        };
-
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
@@ -716,12 +692,19 @@ class SyncedEventFilterNode :
         REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
             GetObjectId(*this), turn.Id()));
 
+        // Don't time if there is nothing to do
+        if (! source_->Events().empty())
         {// timer
             using TimerT = typename SyncedEventFilterNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, source_->Events().size() );
 
             for (const auto& e : source_->Events())
-                if (apply(EvalFunctor_( e, filter_ ), deps_))
+                if (apply(
+                        [this, &e] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
+                        {
+                            return filter_(e, args->ValueRef() ...);
+                        },
+                        deps_))
                     this->events_.push_back(e);
         }// ~timer
 
@@ -751,6 +734,168 @@ class SyncedEventFilterNode :
     DepHolderT  deps_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventProcessingNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename D,
+    typename TIn,
+    typename TOut,
+    typename TFunc
+>
+class EventProcessingNode :
+    public EventStreamNode<D,TOut>
+{
+    using Engine = typename EventProcessingNode::Engine;
+
+public:
+    template <typename F>
+    EventProcessingNode(const std::shared_ptr<EventStreamNode<D,TIn>>& source, F&& func) :
+        EventProcessingNode::EventStreamNode( ),
+        source_( source ),
+        func_( std::forward<F>(func) )
+    {
+        Engine::OnNodeCreate(*this);
+        Engine::OnNodeAttach(*this, *source);
+    }
+
+    ~EventProcessingNode()
+    {
+        Engine::OnNodeDetach(*this, *source_);
+        Engine::OnNodeDestroy(*this);
+    }
+
+    virtual void Tick(void* turnPtr) override
+    {
+        using TurnT = typename D::Engine::TurnT;
+        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+
+        this->SetCurrentTurn(turn, true);
+
+        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
+            GetObjectId(*this), turn.Id()));
+
+        {// timer
+            using TimerT = typename EventProcessingNode::ScopedUpdateTimer;
+            TimerT scopedTimer( *this, source_->Events().size() );
+
+            func_(
+                EventRange<TIn>( source_->Events() ),
+                std::back_inserter(this->events_));
+        }// ~timer
+
+        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
+            GetObjectId(*this), turn.Id()));
+
+        if (! this->events_.empty())
+            Engine::OnNodePulse(*this, turn);
+        else
+            Engine::OnNodeIdlePulse(*this, turn);
+    }
+
+    virtual const char* GetNodeType() const override        { return "EventProcessingNode"; }
+    virtual int         DependencyCount() const override    { return 1; }
+
+private:
+    std::shared_ptr<EventStreamNode<D,TIn>>   source_;
+
+    TFunc       func_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SyncedEventProcessingNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename D,
+    typename TIn,
+    typename TOut,
+    typename TFunc,
+    typename ... TDepValues
+>
+class SyncedEventProcessingNode :
+    public EventStreamNode<D,TOut>
+{
+    using Engine = typename SyncedEventProcessingNode::Engine;
+
+public:
+    template <typename F>
+    SyncedEventProcessingNode(const std::shared_ptr<EventStreamNode<D,TIn>>& source, F&& func, 
+                             const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
+        SyncedEventProcessingNode::EventStreamNode( ),
+        source_( source ),
+        func_( std::forward<F>(func) ),
+        deps_( deps ... )
+    {
+        Engine::OnNodeCreate(*this);
+        Engine::OnNodeAttach(*this, *source);
+        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+    }
+
+    ~SyncedEventProcessingNode()
+    {
+        Engine::OnNodeDetach(*this, *source_);
+
+        apply(
+            DetachFunctor<D,SyncedEventProcessingNode,
+                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
+            deps_);
+
+        Engine::OnNodeDestroy(*this);
+    }
+
+    virtual void Tick(void* turnPtr) override
+    {
+        using TurnT = typename D::Engine::TurnT;
+        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+
+        this->SetCurrentTurn(turn, true);
+        // Update of this node could be triggered from deps,
+        // so make sure source doesnt contain events from last turn
+        source_->SetCurrentTurn(turn);
+
+        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
+            GetObjectId(*this), turn.Id()));
+
+        // Don't time if there is nothing to do
+        if (! source_->Events().empty())
+        {// timer
+            using TimerT = typename SyncedEventProcessingNode::ScopedUpdateTimer;
+            TimerT scopedTimer( *this, source_->Events().size() );
+
+            apply(
+                [this] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
+                {
+                    func_(
+                        EventRange<TIn>( source_->Events() ),
+                        std::back_inserter(this->events_));
+                },
+                deps_);
+
+        }// ~timer
+
+        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
+            GetObjectId(*this), turn.Id()));
+
+        if (! this->events_.empty())
+            Engine::OnNodePulse(*this, turn);
+        else
+            Engine::OnNodeIdlePulse(*this, turn);
+    }
+
+    virtual const char* GetNodeType() const override        { return "SycnedEventProcessingNode"; }
+    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+
+private:
+    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
+
+    std::shared_ptr<EventStreamNode<D,TIn>>   source_;
+
+    TFunc       func_;
+    DepHolderT  deps_;
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_EVENTNODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 38979813..9ce6a9ef 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -245,6 +245,30 @@ class ReactiveOpBase
     DepHolderT   deps_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Iterators for event processing
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E>
+class EventRange
+{
+public:
+    using const_iterator = typename std::vector<E>::const_iterator;
+
+    EventRange(const EventRange&) = default;
+
+    const_iterator begin() const    { return data_.begin(); }
+    const_iterator end() const      { return data_.end(); }
+
+    explicit EventRange(const std::vector<E>& data) :
+        data_( data )
+    {}
+
+private:
+    const std::vector<E>&    data_;
+};
+
+template <typename E>
+using EventInserter = std::back_insert_iterator<std::vector<E>>;
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index a2d4c1df..351a54e5 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -38,6 +38,39 @@ enum class ObserverAction
     stop_and_detach
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// AddObserverRangeWrapper
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E, typename F, typename ... TArgs>
+struct AddObserverRangeWrapper
+{
+    AddObserverRangeWrapper(const AddObserverRangeWrapper& other) = default;
+
+    AddObserverRangeWrapper(AddObserverRangeWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template
+    <
+        typename FIn,
+        class = typename DisableIfSame<FIn,AddObserverRangeWrapper>::type
+    >
+    explicit AddObserverRangeWrapper(FIn&& func) :
+        MyFunc( std::forward<FIn>(func) )
+    {}
+
+    ObserverAction operator()(EventRange<E> range, const TArgs& ... args)
+    {
+        for (const auto& e : range)
+            if (MyFunc(e, args ...) == ObserverAction::stop_and_detach)
+                return ObserverAction::stop_and_detach;
+
+        return ObserverAction::next;
+    }
+
+    F MyFunc;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -183,15 +216,9 @@ class EventObserverNode :
         {// timer
             using TimerT = typename EventObserverNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, p->Events().size() );
-            
-            for (const auto& e : p->Events())
-            {
-                if (func_(e) == ObserverAction::stop_and_detach)
-                {
-                    shouldDetach = true;
-                    break;
-                }
-            }
+
+            shouldDetach = func_(EventRange<E>( p->Events() )) == ObserverAction::stop_and_detach;
+
         }// ~timer
 
         if (shouldDetach)
@@ -263,22 +290,6 @@ class SyncedObserverNode :
 
     virtual void Tick(void* turnPtr) override
     {
-        struct EvalFunctor_
-        {
-            EvalFunctor_(const E& e, TFunc& f) :
-                MyEvent( e ),
-                MyFunc( f )
-            {}
-
-            ObserverAction operator()(const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-            {
-                return MyFunc(MyEvent, args->ValueRef() ...);
-            }
-
-            const E&    MyEvent;
-            TFunc&      MyFunc;
-        };
-
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
@@ -297,14 +308,13 @@ class SyncedObserverNode :
                 using TimerT = typename SyncedObserverNode::ScopedUpdateTimer;
                 TimerT scopedTimer( *this, p->Events().size() );
             
-                for (const auto& e : p->Events())
-                {
-                    if (apply(EvalFunctor_( e, func_ ), deps_) == ObserverAction::stop_and_detach)
+                shouldDetach = apply(
+                    [this, &p] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
                     {
-                        shouldDetach = true;
-                        break;
-                    }
-                }
+                        return func_(EventRange<E>( p->Events() ), args->ValueRef() ...);
+                    },
+                    deps_) == ObserverAction::stop_and_detach;
+
             }// ~timer
         }
 

From 301202026c6cd67314b7ca1f1e60858c5a3804fc Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 7 Aug 2014 13:58:06 +0200
Subject: [PATCH 13/75] Improved static_assert error messages.

---
 include/react/Domain.h   | 36 +++++++++++++++++++++++++++---------
 include/react/Observer.h | 38 +++++++++++++++++++++++++++-----------
 2 files changed, 54 insertions(+), 20 deletions(-)

diff --git a/include/react/Domain.h b/include/react/Domain.h
index ac049438..8bbf6f00 100644
--- a/include/react/Domain.h
+++ b/include/react/Domain.h
@@ -195,7 +195,7 @@ auto MakeContinuation(TransactionFlagsT flags, const Signal<D,S>& trigger, FIn&&
     -> Continuation<D,DOut>
 {
     static_assert(DOut::is_concurrent,
-        "MakeContinuation requires support for concurrent input to target domain.");
+        "MakeContinuation: Target domain does not support concurrent input.");
 
     using REACT_IMPL::SignalContinuationNode;
     using F = typename std::decay<FIn>::type;
@@ -232,7 +232,7 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&&
     -> Continuation<D,DOut>
 {
     static_assert(DOut::is_concurrent,
-        "MakeContinuation requires support for concurrent input to target domain.");
+        "MakeContinuation: Target domain does not support concurrent input.");
 
     using REACT_IMPL::EventContinuationNode;
     using REACT_IMPL::AddContinuationRangeWrapper;
@@ -245,9 +245,16 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&&
         typename std::conditional<
             IsCallableWith<F,void, EventRange<E>>::value,
             F,
-            AddContinuationRangeWrapper<E, F>
+            typename std::conditional<
+                IsCallableWith<F, void, E>::value,
+                AddContinuationRangeWrapper<E, F>,
+                void
+            >::type
         >::type;
 
+    static_assert(! std::is_same<WrapperT,void>::value,
+        "MakeContinuation: Passed function does not match any of the supported signatures.");
+
     return Continuation<D,DOut>(
         std::make_shared<EventContinuationNode<D,DOut,E,WrapperT>>(
             flags, GetNodePtr(trigger), std::forward<FIn>(func)));
@@ -282,7 +289,7 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger,
     -> Continuation<D,DOut>
 {
     static_assert(DOut::is_concurrent,
-        "MakeContinuation requires support for concurrent input to target domain.");
+        "MakeContinuation: Target domain does not support concurrent input.");
 
     using REACT_IMPL::SyncedContinuationNode;
     using REACT_IMPL::AddContinuationRangeWrapper;
@@ -295,9 +302,16 @@ auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger,
         typename std::conditional<
             IsCallableWith<F, void, EventRange<E>, TDepValues ...>::value,
             F,
-            AddContinuationRangeWrapper<E, F, TDepValues ...>
+            typename std::conditional<
+                IsCallableWith<F, void, E, TDepValues ...>::value,
+                AddContinuationRangeWrapper<E, F, TDepValues ...>,
+                void
+            >::type
         >::type;
 
+    static_assert(! std::is_same<WrapperT,void>::value,
+        "MakeContinuation: Passed function does not match any of the supported signatures.");
+
     struct NodeBuilder_
     {
         NodeBuilder_(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&& func) :
@@ -364,7 +378,8 @@ void DoTransaction(TransactionFlagsT flags, F&& func)
 template <typename D, typename F>
 void AsyncTransaction(F&& func)
 {
-    static_assert(D::is_concurrent, "AsyncTransaction requires concurrent domain.");
+    static_assert(D::is_concurrent,
+        "AsyncTransaction: Domain does not support concurrent input.");
 
     using REACT_IMPL::DomainSpecificInputManager;
     DomainSpecificInputManager<D>::Instance()
@@ -374,7 +389,8 @@ void AsyncTransaction(F&& func)
 template <typename D, typename F>
 void AsyncTransaction(TransactionFlagsT flags, F&& func)
 {
-    static_assert(D::is_concurrent, "AsyncTransaction requires concurrent domain.");
+    static_assert(D::is_concurrent,
+        "AsyncTransaction: Domain does not support concurrent input.");
 
     using REACT_IMPL::DomainSpecificInputManager;
     DomainSpecificInputManager<D>::Instance()
@@ -384,7 +400,8 @@ void AsyncTransaction(TransactionFlagsT flags, F&& func)
 template <typename D, typename F>
 void AsyncTransaction(TransactionStatus& status, F&& func)
 {
-    static_assert(D::is_concurrent, "AsyncTransaction requires concurrent domain.");
+    static_assert(D::is_concurrent,
+        "AsyncTransaction: Domain does not support concurrent input.");
 
     using REACT_IMPL::DomainSpecificInputManager;
 
@@ -395,7 +412,8 @@ void AsyncTransaction(TransactionStatus& status, F&& func)
 template <typename D, typename F>
 void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& func)
 {
-    static_assert(D::is_concurrent, "AsyncTransaction requires concurrent domain.");
+    static_assert(D::is_concurrent,
+        "AsyncTransaction: Domain does not support concurrent input.");
 
     using REACT_IMPL::DomainSpecificInputManager;
     DomainSpecificInputManager<D>::Instance()
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 9b50fc6a..45fd78a1 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -179,7 +179,7 @@ auto Observe(const Signal<D,S>& subject, FIn&& func)
 
     // If return value of passed function is void, add ObserverAction::next as
     // default return value.
-    using TNode = typename std::conditional<
+    using NodeT = typename std::conditional<
         std::is_same<void,R>::value,
         SignalObserverNode<D,S,WrapperT>,
         SignalObserverNode<D,S,F>
@@ -187,7 +187,7 @@ auto Observe(const Signal<D,S>& subject, FIn&& func)
 
     const auto& subjectPtr = GetNodePtr(subject);
 
-    std::unique_ptr<ObserverNode<D>> nodePtr( new TNode(subjectPtr, std::forward<FIn>(func)) );
+    std::unique_ptr<ObserverNode<D>> nodePtr( new NodeT(subjectPtr, std::forward<FIn>(func)) );
     ObserverNode<D>* rawNodePtr = nodePtr.get();
 
     subjectPtr->RegisterObserver(std::move(nodePtr));
@@ -227,17 +227,25 @@ auto Observe(const Events<D,E>& subject, FIn&& func)
                 typename std::conditional<
                     IsCallableWith<F, void, EventRange<E>>::value,
                     AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
-                    AddObserverRangeWrapper<E,
-                        AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>>
+                    typename std::conditional<
+                        IsCallableWith<F, void, E>::value,
+                        AddObserverRangeWrapper<E,
+                            AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>>,
+                        void
+                    >::type
                 >::type
             >::type
         >::type;
+
+    static_assert(
+        ! std::is_same<WrapperT,void>::value,
+        "Observe: Passed function does not match any of the supported signatures.");
     
-    using TNode = EventObserverNode<D,E,WrapperT>;
+    using NodeT = EventObserverNode<D,E,WrapperT>;
     
     const auto& subjectPtr = GetNodePtr(subject);
 
-    std::unique_ptr<ObserverNode<D>> nodePtr( new TNode(subjectPtr, std::forward<FIn>(func)) );
+    std::unique_ptr<ObserverNode<D>> nodePtr( new NodeT(subjectPtr, std::forward<FIn>(func)) );
     ObserverNode<D>* rawNodePtr = nodePtr.get();
 
     subjectPtr->RegisterObserver(std::move(nodePtr));
@@ -279,14 +287,22 @@ auto Observe(const Events<D,E>& subject,
                 typename std::conditional<
                     IsCallableWith<F, void, EventRange<E>, TDepValues ...>::value,
                     AddDefaultReturnValueWrapper<F, ObserverAction ,ObserverAction::next>,
-                    AddObserverRangeWrapper<E,
-                        AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
-                        TDepValues...>
+                    typename std::conditional<
+                        IsCallableWith<F, void, E, TDepValues ...>::value,
+                        AddObserverRangeWrapper<E,
+                            AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
+                                TDepValues...>,
+                            void
+                        >::type
                 >::type
             >::type
         >::type;
 
-    using TNode = SyncedObserverNode<D,E,WrapperT,TDepValues ...>;
+    static_assert(
+        ! std::is_same<WrapperT,void>::value,
+        "Observe: Passed function does not match any of the supported signatures.");
+
+    using NodeT = SyncedObserverNode<D,E,WrapperT,TDepValues ...>;
 
     struct NodeBuilder_
     {
@@ -298,7 +314,7 @@ auto Observe(const Events<D,E>& subject,
         auto operator()(const Signal<D,TDepValues>& ... deps)
             -> ObserverNode<D>*
         {
-            return new TNode(
+            return new NodeT(
                 GetNodePtr(MySubject), std::forward<FIn>(MyFunc), GetNodePtr(deps) ... );
         }
 

From 794835380609f3c5c54b306e69eb432e77a741dd Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 7 Aug 2014 13:58:46 +0200
Subject: [PATCH 14/75] Added some convenience functions to EventRange.

---
 include/react/detail/graph/GraphBase.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 9ce6a9ef..2adf8160 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -253,12 +253,16 @@ class EventRange
 {
 public:
     using const_iterator = typename std::vector<E>::const_iterator;
+    using size_type = typename std::vector<E>::size_type;
 
     EventRange(const EventRange&) = default;
 
     const_iterator begin() const    { return data_.begin(); }
     const_iterator end() const      { return data_.end(); }
 
+    size_type   Size() const        { return data_.size(); }
+    bool        IsEmpty() const     { return data_.empty(); }
+
     explicit EventRange(const std::vector<E>& data) :
         data_( data )
     {}

From 3ff8cdcba524692536e0096ae25604f73228ad47 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 7 Aug 2014 13:59:29 +0200
Subject: [PATCH 15/75] Added EventRange support to Iterate.

---
 include/react/Algorithm.h                   |  78 +++++++++---
 include/react/detail/graph/AlgorithmNodes.h | 124 ++++++++++++--------
 2 files changed, 138 insertions(+), 64 deletions(-)

diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index 2f0e7730..7caed812 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -77,7 +77,7 @@ auto Monitor(const Signal<D,S>& target)
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate - Iteratively combines signal value with values from event stream
+/// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
@@ -92,17 +92,38 @@ auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
+    using REACT_IMPL::AddIterateRangeWrapper;
+    using REACT_IMPL::AddIterateByRefRangeWrapper;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::EventRange;
 
     using F = typename std::decay<FIn>::type;
-    using R = typename std::result_of<FIn(E,S&)>::type;
-    using TNode = typename std::conditional<
-        std::is_same<void,R>::value,
-        IterateByRefNode<D,S,E,F>,
-        IterateNode<D,S,E,F>
-            >::type;
+
+    using NodeT =
+        typename std::conditional<
+            IsCallableWith<F,S,EventRange<E>,S>::value,
+            IterateNode<D,S,E,F>,
+            typename std::conditional<
+                IsCallableWith<F,S,E,S>::value,
+                IterateNode<D,S,E,AddIterateRangeWrapper<E,S,F>>,
+                typename std::conditional<
+                    IsCallableWith<F, void, EventRange<E>, S&>::value,
+                    IterateByRefNode<D,S,E,F>,
+                    typename std::conditional<
+                        IsCallableWith<F,void,E,S&>::value,
+                        IterateByRefNode<D,S,E,AddIterateByRefRangeWrapper<E,S,F>>,
+                        void
+                    >::type
+                >::type
+            >::type
+        >::type;
+
+    static_assert(
+        ! std::is_same<NodeT,void>::value,
+        "Iterate: Passed function does not match any of the supported signatures.");
 
     return Signal<D,S>(
-        std::make_shared<TNode>(
+        std::make_shared<NodeT>(
             std::forward<V>(init), GetNodePtr(events), std::forward<FIn>(func)));
 }
 
@@ -124,14 +145,41 @@ auto Iterate(const Events<D,E>& events, V&& init,
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
+    using REACT_IMPL::AddIterateRangeWrapper;
+    using REACT_IMPL::AddIterateByRefRangeWrapper;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::EventRange;
 
     using F = typename std::decay<FIn>::type;
-    using R = typename std::result_of<FIn(E,S&,TDepValues...)>::type;
-    using TNode = typename std::conditional<
-        std::is_same<void,R>::value,
-        SyncedIterateByRefNode<D,S,E,F,TDepValues ...>,
-        SyncedIterateNode<D,S,E,F,TDepValues ...>
-            >::type;
+
+    using NodeT =
+        typename std::conditional<
+            IsCallableWith<F,S,EventRange<E>,S,TDepValues ...>::value,
+            SyncedIterateNode<D,S,E,F,TDepValues ...>,
+            typename std::conditional<
+                IsCallableWith<F,S,E,S,TDepValues ...>::value,
+                SyncedIterateNode<D,S,E,
+                    AddIterateRangeWrapper<E,S,F,TDepValues ...>,
+                    TDepValues ...>,
+                typename std::conditional<
+                    IsCallableWith<F,void,EventRange<E>,S&,TDepValues ...>::value,
+                    SyncedIterateByRefNode<D,S,E,F,TDepValues ...>,
+                    typename std::conditional<
+                        IsCallableWith<F,void,E,S&,TDepValues ...>::value,
+                        SyncedIterateByRefNode<D,S,E,
+                            AddIterateByRefRangeWrapper<E,S,F,TDepValues ...>,
+                            TDepValues ...>,
+                        void
+                    >::type
+                >::type
+            >::type
+        >::type;
+
+    static_assert(
+        ! std::is_same<NodeT,void>::value,
+        "Iterate: Passed function does not match any of the supported signatures.");
+
+    //static_assert(NodeT::dummy_error, "DUMP MY TYPE" );
 
     struct NodeBuilder_
     {
@@ -145,7 +193,7 @@ auto Iterate(const Events<D,E>& events, V&& init,
             -> Signal<D,S>
         {
             return Signal<D,S>(
-                std::make_shared<TNode>(
+                std::make_shared<NodeT>(
                     std::forward<V>(MyInit), GetNodePtr(MySource),
                     std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
         }
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index fc89aaf9..3c061c68 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -19,6 +19,65 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// AddIterateRangeWrapper
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E, typename S, typename F, typename ... TArgs>
+struct AddIterateRangeWrapper
+{
+    AddIterateRangeWrapper(const AddIterateRangeWrapper& other) = default;
+
+    AddIterateRangeWrapper(AddIterateRangeWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template
+    <
+        typename FIn,
+        class = typename DisableIfSame<FIn,AddIterateRangeWrapper>::type
+    >
+    explicit AddIterateRangeWrapper(FIn&& func) :
+        MyFunc( std::forward<FIn>(func) )
+    {}
+
+    S operator()(EventRange<E> range, S value, const TArgs& ... args)
+    {
+        for (const auto& e : range)
+            value = MyFunc(e, value, args ...);
+
+        return value;
+    }
+
+    F MyFunc;
+};
+
+template <typename E, typename S, typename F, typename ... TArgs>
+struct AddIterateByRefRangeWrapper
+{
+    AddIterateByRefRangeWrapper(const AddIterateByRefRangeWrapper& other) = default;
+
+    AddIterateByRefRangeWrapper(AddIterateByRefRangeWrapper&& other) :
+        MyFunc( std::move(other.MyFunc) )
+    {}
+
+    template
+    <
+        typename FIn,
+        class = typename DisableIfSame<FIn,AddIterateByRefRangeWrapper>::type
+    >
+    explicit AddIterateByRefRangeWrapper(FIn&& func) :
+        MyFunc( std::forward<FIn>(func) )
+    {}
+
+    void operator()(EventRange<E> range, S& valueRef, const TArgs& ... args)
+    {
+        for (const auto& e : range)
+            MyFunc(e, valueRef, args ...);
+    }
+
+    F MyFunc;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -65,10 +124,7 @@ class IterateNode :
             using TimerT = typename IterateNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, events_->Events().size() );
 
-            S newValue = this->value_;
-            
-            for (const auto& e : events_->Events())
-                newValue = func_(e, newValue);
+            S newValue = func_(EventRange<E>( events_->Events() ),  this->value_);
 
             if (! Equals(newValue, this->value_))
             {
@@ -139,8 +195,8 @@ class IterateByRefNode :
             using TimerT = typename IterateByRefNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, events_->Events().size() );
 
-            for (const auto& e : events_->Events())
-                func_(e, this->value_);
+            func_(EventRange<E>( events_->Events() ), this->value_);
+
         }// ~timer
 
         REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
@@ -203,24 +259,6 @@ class SyncedIterateNode :
 
     virtual void Tick(void* turnPtr) override
     {
-        struct EvalFunctor_
-        {
-            EvalFunctor_(const E& e, const S& v, TFunc& f) :
-                MyEvent( e ),
-                MyValue( v ),
-                MyFunc( f )
-            {}
-
-            S operator()(const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-            {
-                return MyFunc(MyEvent, MyValue, args->ValueRef() ...);
-            }
-
-            const E&    MyEvent;
-            const S&    MyValue;
-            TFunc&      MyFunc;
-        };
-
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
@@ -235,11 +273,13 @@ class SyncedIterateNode :
         {// timer
             using TimerT = typename SyncedIterateNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, events_->Events().size() );
-
-            S newValue = this->value_;
-
-            for (const auto& e : events_->Events())
-                newValue = apply(EvalFunctor_( e, std::move(newValue), func_ ), deps_);
+            
+            S newValue = apply(
+                [this] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
+                {
+                    return func_(EventRange<E>( events_->Events() ), this->value_, args->ValueRef() ...);
+                },
+                deps_);
 
             if (! Equals(newValue, this->value_))
             {
@@ -313,24 +353,6 @@ class SyncedIterateByRefNode :
 
     virtual void Tick(void* turnPtr) override
     {
-        struct EvalFunctor_
-        {
-            EvalFunctor_(const E& e, S& v, TFunc& f) :
-                MyEvent( e ),
-                MyValue( v ),
-                MyFunc( f )
-            {}
-
-            void operator()(const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-            {
-                MyFunc(MyEvent, MyValue, args->ValueRef() ...);
-            }
-
-            const E&    MyEvent;
-            S&          MyValue;
-            TFunc&      MyFunc;
-        };
-
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
@@ -346,8 +368,12 @@ class SyncedIterateByRefNode :
             using TimerT = typename SyncedIterateByRefNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, events_->Events().size() );
 
-            for (const auto& e : events_->Events())
-                apply(EvalFunctor_( e, this->value_, func_ ), deps_);
+            apply(
+                [this] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
+                {
+                    func_(EventRange<E>( events_->Events() ), this->value_, args->ValueRef() ...);
+                },
+                deps_);
 
             changed = true;
         }// ~timer

From 33ba9c3c283d5334d1fdba3bd4fcf300a76610e7 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 7 Aug 2014 14:00:08 +0200
Subject: [PATCH 16/75] Added test cases for EventRange Iterate.

---
 tests/src/OperationsTest.h | 222 +++++++++++++++++++++++++++++++++++++
 1 file changed, 222 insertions(+)

diff --git a/tests/src/OperationsTest.h b/tests/src/OperationsTest.h
index 87c54f35..a10167c8 100644
--- a/tests/src/OperationsTest.h
+++ b/tests/src/OperationsTest.h
@@ -586,6 +586,226 @@ TYPED_TEST_P(OperationsTest, SyncedIterate2)
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SyncedIterate3 test (event range)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+TYPED_TEST_P(OperationsTest, SyncedIterate3)
+{
+    using D = typename SyncedIterate3::MyDomain;
+
+    auto in1 = MakeVar<D>(1);
+    auto in2 = MakeVar<D>(1);
+
+    auto op1 = in1 + in2;
+    auto op2 = (in1 + in2) * 10;
+
+    auto src1 = MakeEventSource<D>();
+    auto src2 = MakeEventSource<D,int>();
+
+    auto out1 = Iterate(
+        src1,
+        make_tuple(0,0),
+        With(op1,op2),
+        [] (EventRange<Token> range, const tuple<int,int>& t, int op1, int op2) {
+            return make_tuple(
+                get<0>(t) + (op1 * range.Size()),
+                get<1>(t) + (op2 * range.Size()));
+        });
+
+    auto out2 = Iterate(
+        src2,
+        make_tuple(0,0,0),
+        With(op1,op2),
+        [] (EventRange<int> range, const tuple<int,int,int>& t, int op1, int op2) {
+            int sum = 0;
+            for (const auto& e : range)
+                sum += e;
+
+            return make_tuple(
+                get<0>(t) + sum,
+                get<1>(t) + (op1 * range.Size()),
+                get<2>(t) + (op2 * range.Size()));
+        });
+
+    int obsCount1 = 0;
+    int obsCount2 = 0;
+
+    {
+        auto obs1 = Observe(out1, [&] (const tuple<int,int>& t) {
+            ++obsCount1;
+
+            ASSERT_EQ(get<0>(t), 33);
+            ASSERT_EQ(get<1>(t), 330);
+        });
+
+        auto obs2 = Observe(out2, [&] (const tuple<int,int,int>& t) {
+            ++obsCount2;
+
+            ASSERT_EQ(get<0>(t), 42);
+            ASSERT_EQ(get<1>(t), 33);
+            ASSERT_EQ(get<2>(t), 330);
+        });
+
+        in1 <<= 22;
+        in2 <<= 11;
+
+        src1.Emit();
+        src2.Emit(42);
+
+        ASSERT_EQ(obsCount1, 1);
+        ASSERT_EQ(obsCount2, 1);
+
+        obs1.Detach();
+        obs2.Detach();
+    }
+
+    {
+        auto obs1 = Observe(out1, [&] (const tuple<int,int>& t) {
+            ++obsCount1;
+
+            ASSERT_EQ(get<0>(t), 33 + 330);
+            ASSERT_EQ(get<1>(t), 330 + 3300);
+        });
+
+        auto obs2 = Observe(out2, [&] (const tuple<int,int,int>& t) {
+            ++obsCount2;
+
+            ASSERT_EQ(get<0>(t), 42 + 420);
+            ASSERT_EQ(get<1>(t), 33 + 330);
+            ASSERT_EQ(get<2>(t), 330 + 3300);
+        });
+
+        in1 <<= 220;
+        in2 <<= 110;
+
+        src1.Emit();
+        src2.Emit(420);
+
+        ASSERT_EQ(obsCount1, 2);
+        ASSERT_EQ(obsCount2, 2);
+
+        obs1.Detach();
+        obs2.Detach();
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SyncedIterate4 test (event range, by ref)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+TYPED_TEST_P(OperationsTest, SyncedIterate4)
+{
+    using D = typename SyncedIterate4::MyDomain;
+
+    auto in1 = MakeVar<D>(1);
+    auto in2 = MakeVar<D>(1);
+
+    auto op1 = in1 + in2;
+    auto op2 = (in1 + in2) * 10;
+
+    auto src1 = MakeEventSource<D>();
+    auto src2 = MakeEventSource<D,int>();
+
+    auto out1 = Iterate(
+        src1,
+        vector<int>{},
+        With(op1,op2),
+        [] (EventRange<Token> range, vector<int>& v, int op1, int op2) -> void {
+            for (const auto& e : range)
+            {
+                v.push_back(op1);
+                v.push_back(op2);
+            }
+        });
+
+    auto out2 = Iterate(
+        src2,
+        vector<int>{},
+        With(op1,op2),
+        [] (EventRange<int> range, vector<int>& v, int op1, int op2) -> void {
+            for (const auto& e : range)
+            {
+                v.push_back(e);
+                v.push_back(op1);
+                v.push_back(op2);
+            }
+        });
+
+    int obsCount1 = 0;
+    int obsCount2 = 0;
+
+    {
+        auto obs1 = Observe(out1, [&] (const vector<int>& v) {
+            ++obsCount1;
+
+            ASSERT_EQ(v.size(), 2);
+
+            ASSERT_EQ(v[0], 33);
+            ASSERT_EQ(v[1], 330);
+        });
+
+        auto obs2 = Observe(out2, [&] (const vector<int>& v) {
+            ++obsCount2;
+
+            ASSERT_EQ(v.size(), 3);
+
+            ASSERT_EQ(v[0], 42);
+            ASSERT_EQ(v[1], 33);
+            ASSERT_EQ(v[2], 330);
+        });
+
+        in1 <<= 22;
+        in2 <<= 11;
+
+        src1.Emit();
+        src2.Emit(42);
+
+        ASSERT_EQ(obsCount1, 1);
+        ASSERT_EQ(obsCount2, 1);
+
+        obs1.Detach();
+        obs2.Detach();
+    }
+
+    {
+        auto obs1 = Observe(out1, [&] (const vector<int>& v) {
+            ++obsCount1;
+
+            ASSERT_EQ(v.size(), 4);
+
+            ASSERT_EQ(v[0], 33);
+            ASSERT_EQ(v[1], 330);
+            ASSERT_EQ(v[2], 330);
+            ASSERT_EQ(v[3], 3300);
+        });
+
+        auto obs2 = Observe(out2, [&] (const vector<int>& v) {
+            ++obsCount2;
+
+            ASSERT_EQ(v.size(), 6);
+
+            ASSERT_EQ(v[0], 42);
+            ASSERT_EQ(v[1], 33);
+            ASSERT_EQ(v[2], 330);
+
+            ASSERT_EQ(v[3], 420);
+            ASSERT_EQ(v[4], 330);
+            ASSERT_EQ(v[5], 3300);
+        });
+
+        in1 <<= 220;
+        in2 <<= 110;
+
+        src1.Emit();
+        src2.Emit(420);
+
+        ASSERT_EQ(obsCount1, 2);
+        ASSERT_EQ(obsCount2, 2);
+
+        obs1.Detach();
+        obs2.Detach();
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventFilter1
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -688,6 +908,8 @@ REGISTER_TYPED_TEST_CASE_P
     SyncedTransform1,
     SyncedIterate1,
     SyncedIterate2,
+    SyncedIterate3,
+    SyncedIterate4,
     SyncedEventFilter1,
     SyncedEventTransform1
 );

From eadf7f370850b474d02a0f84f007beee761efb97 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 8 Aug 2014 01:17:23 +0200
Subject: [PATCH 17/75] IsCallableWith had problems with function pointers on
 MSVC. Using a different SFINAE method fixed it.

---
 include/react/common/Util.h | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/include/react/common/Util.h b/include/react/common/Util.h
index b50c005b..39741ed7 100644
--- a/include/react/common/Util.h
+++ b/include/react/common/Util.h
@@ -206,10 +206,14 @@ class IsCallableWith
     using NoT = char[1];
     using YesT = char[2];
 
-    template <typename U>
-    static YesT& check(
-        decltype( static_cast<TRet>(
-            (std::declval<U>())(std::declval<TArgs>() ...))) *);
+    template
+    <
+        typename U,
+        class = decltype(
+            static_cast<TRet>(
+                (std::declval<U>())(std::declval<TArgs>() ...)))
+    >
+    static YesT& check(void*);
 
     template <typename U>
     static NoT& check(...);

From c3ec931be5390913a567cb10248f22aee46a63f5 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 8 Aug 2014 01:45:46 +0200
Subject: [PATCH 18/75] Added test cases Process.

---
 tests/src/EventStreamTest.h | 53 ++++++++++++++++++++++++++++++++-
 tests/src/OperationsTest.h  | 58 +++++++++++++++++++++++++++++++++++--
 2 files changed, 108 insertions(+), 3 deletions(-)

diff --git a/tests/src/EventStreamTest.h b/tests/src/EventStreamTest.h
index 55a67124..39e2479d 100644
--- a/tests/src/EventStreamTest.h
+++ b/tests/src/EventStreamTest.h
@@ -269,6 +269,56 @@ TYPED_TEST_P(EventStreamTest, EventTransform)
     ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD") != results.end());
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventProcess test
+///////////////////////////////////////////////////////////////////////////////////////////////////
+TYPED_TEST_P(EventStreamTest, EventProcess)
+{
+    using D = typename EventProcess::MyDomain;
+
+    std::vector<float> results;
+
+    auto in1 = MakeEventSource<D,int>();
+    auto in2 = MakeEventSource<D,int>();
+
+    auto merged = Merge(in1, in2);
+    int callCount = 0;
+
+    auto processed = Process<float>(merged,
+        [&] (EventRange<int> range, EventInserter<float> out)
+        {
+            for (const auto& e : range)
+            {
+                *out = 0.1f * e;
+                *out = 1.5f * e;
+            }
+
+            callCount++;
+        });
+
+    Observe(processed,
+        [&] (float s)
+        {
+            results.push_back(s);
+        });
+
+    DoTransaction<D>([&] {
+        in1 << 10 << 20;
+    });
+
+    in2 << 30;
+
+    ASSERT_EQ(results.size(), 6);
+    ASSERT_EQ(callCount, 2);
+
+    ASSERT_EQ(results[0], 1.0f);
+    ASSERT_EQ(results[1], 15.0f);
+    ASSERT_EQ(results[2], 2.0f);
+    ASSERT_EQ(results[3], 30.0f);
+    ASSERT_EQ(results[4], 3.0f);
+    ASSERT_EQ(results[5], 45.0f);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 REGISTER_TYPED_TEST_CASE_P
 (
@@ -278,7 +328,8 @@ REGISTER_TYPED_TEST_CASE_P
     EventMerge2,
     EventMerge3,
     EventFilter,
-    EventTransform
+    EventTransform,
+    EventProcess
 );
 
 } // ~namespace
diff --git a/tests/src/OperationsTest.h b/tests/src/OperationsTest.h
index a10167c8..77e8c399 100644
--- a/tests/src/OperationsTest.h
+++ b/tests/src/OperationsTest.h
@@ -847,7 +847,7 @@ TYPED_TEST_P(OperationsTest, SyncedEventFilter1)
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventTransform1
+/// SyncedEventTransform1
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 TYPED_TEST_P(OperationsTest, SyncedEventTransform1)
 {
@@ -892,6 +892,59 @@ TYPED_TEST_P(OperationsTest, SyncedEventTransform1)
     ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD, Alice Anderson") != results.end());
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SyncedEventProcess1
+///////////////////////////////////////////////////////////////////////////////////////////////////
+TYPED_TEST_P(OperationsTest, SyncedEventProcess1)
+{
+    using D = typename SyncedEventProcess1::MyDomain;
+
+    std::vector<float> results;
+
+    auto in1 = MakeEventSource<D,int>();
+    auto in2 = MakeEventSource<D,int>();
+
+    auto mult = MakeVar<D>(10);
+
+    auto merged = Merge(in1, in2);
+    int callCount = 0;
+
+    auto processed = Process<float>(merged,
+        With(mult),
+        [&] (EventRange<int> range, EventInserter<float> out, int mult)
+        {
+            for (const auto& e : range)
+            {
+                *out = 0.1f * e * mult;
+                *out = 1.5f * e * mult;
+            }
+
+            callCount++;
+        });
+
+    Observe(processed,
+        [&] (float s)
+        {
+            results.push_back(s);
+        });
+
+    DoTransaction<D>([&] {
+        in1 << 10 << 20;
+    });
+
+    in2 << 30;
+
+    ASSERT_EQ(results.size(), 6);
+    ASSERT_EQ(callCount, 2);
+
+    ASSERT_EQ(results[0], 10.0f);
+    ASSERT_EQ(results[1], 150.0f);
+    ASSERT_EQ(results[2], 20.0f);
+    ASSERT_EQ(results[3], 300.0f);
+    ASSERT_EQ(results[4], 30.0f);
+    ASSERT_EQ(results[5], 450.0f);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 REGISTER_TYPED_TEST_CASE_P
 (
@@ -911,7 +964,8 @@ REGISTER_TYPED_TEST_CASE_P
     SyncedIterate3,
     SyncedIterate4,
     SyncedEventFilter1,
-    SyncedEventTransform1
+    SyncedEventTransform1,
+    SyncedEventProcess1
 );
 
 } // ~namespace

From 2acc6ece1d36aa8a44effb8efe843a81f4175b89 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 8 Aug 2014 01:46:38 +0200
Subject: [PATCH 19/75] Fixed synced Process + cleanup.

---
 include/react/detail/graph/AlgorithmNodes.h | 2 +-
 include/react/detail/graph/EventNodes.h     | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 3c061c68..454fdfbb 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -124,7 +124,7 @@ class IterateNode :
             using TimerT = typename IterateNode::ScopedUpdateTimer;
             TimerT scopedTimer( *this, events_->Events().size() );
 
-            S newValue = func_(EventRange<E>( events_->Events() ),  this->value_);
+            S newValue = func_(EventRange<E>( events_->Events() ), this->value_);
 
             if (! Equals(newValue, this->value_))
             {
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index bc4eb4b3..499cda24 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -783,6 +783,7 @@ class EventProcessingNode :
             func_(
                 EventRange<TIn>( source_->Events() ),
                 std::back_inserter(this->events_));
+
         }// ~timer
 
         REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
@@ -869,7 +870,8 @@ class SyncedEventProcessingNode :
                 {
                     func_(
                         EventRange<TIn>( source_->Events() ),
-                        std::back_inserter(this->events_));
+                        std::back_inserter(this->events_),
+                        args->ValueRef() ...);
                 },
                 deps_);
 

From c29d50e7128a8052705285d6e3fe963190ce9f1a Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sat, 9 Aug 2014 14:38:20 +0200
Subject: [PATCH 20/75] Async queue no longer uses a dedicated worker thread.
 Instead, a task is started as soon as there are items in the queue and
 stopped once it's empty.

---
 include/react/detail/ReactiveInput.h | 177 ++++++++++++++++++++++-----
 1 file changed, 147 insertions(+), 30 deletions(-)

diff --git a/include/react/detail/ReactiveInput.h b/include/react/detail/ReactiveInput.h
index dbab6b1f..3589d8c7 100644
--- a/include/react/detail/ReactiveInput.h
+++ b/include/react/detail/ReactiveInput.h
@@ -19,10 +19,10 @@
 #include <memory>
 #include <mutex>
 #include <utility>
-#include <thread>
 #include <type_traits>
 #include <vector>
 
+#include "tbb/task.h"
 #include "tbb/concurrent_queue.h"
 #include "tbb/enumerable_thread_specific.h"
 #include "tbb/queuing_mutex.h"
@@ -39,6 +39,9 @@
 struct IInputNode;
 class IObserver;
 
+template <typename D>
+class InputManager;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Common types & constants
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -478,37 +481,142 @@ class TransactionQueue<concurrent_input>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// InputManager
+/// AsyncWorker
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+struct AsyncItem
+{
+    TransactionFlagsT       Flags;
+    WaitingStatePtrT        WaitingStatePtr;
+    TransactionFuncT        Func;
+};
+
+// Interface
+template <typename D, EInputMode>
+class AsyncWorker
+{
+public:
+    AsyncWorker(InputManager<D>& mgr);
+
+    void PushItem(AsyncItem&& item);
+
+    void PopItem(AsyncItem& item);
+    bool TryPopItem(AsyncItem& item);
+
+    bool IncrementItemCount(size_t n);
+    bool DecrementItemCount(size_t n);
+
+    void Start();
+};
+
+// Disabled
 template <typename D>
-class InputManager :
-    public IContinuationTarget
+struct AsyncWorker<D, consecutive_input>
 {
-private:
-    struct AsyncItem
+public:
+    AsyncWorker(InputManager<D>& mgr)
+    {}
+
+    void PushItem(AsyncItem&& item)     { assert(false); }
+
+    void PopItem(AsyncItem& item)       { assert(false); }
+    bool TryPopItem(AsyncItem& item)    { assert(false); return false; }
+
+    bool IncrementItemCount(size_t n)   { assert(false); return false; }
+    bool DecrementItemCount(size_t n)   { assert(false); return false; }
+
+    void Start()                        { assert(false); }
+};
+
+// Enabled
+template <typename D>
+struct AsyncWorker<D, concurrent_input>
+{
+    using DataT = tbb::concurrent_bounded_queue<AsyncItem>;
+
+    class WorkerTask : public tbb::task
     {
-        TransactionFlagsT              Flags;
-        WaitingStatePtrT        WaitingStatePtr;
-        TransactionFuncT        Func;
+    public:
+        WorkerTask(InputManager<D>& mgr) :
+            mgr_( mgr )
+        {}
+
+        tbb::task* execute()
+        {
+            mgr_.processAsyncQueue();
+            return nullptr;
+        }
+
+    private:
+        InputManager<D>& mgr_;
     };
 
-    using AsyncQueueT = tbb::concurrent_bounded_queue<AsyncItem>;
+public:
+    AsyncWorker(InputManager<D>& mgr) :
+        mgr_( mgr )
+    {}
+
+    void PushItem(AsyncItem&& item)
+    {
+        data_.push(std::move(item));
+    }
 
+    void PopItem(AsyncItem& item)
+    {
+        data_.pop(item);
+    }
+
+    bool TryPopItem(AsyncItem& item)
+    {
+        return data_.try_pop(item);
+    }
+
+    bool IncrementItemCount(size_t n)
+    {
+        return count_.fetch_add(n, std::memory_order_relaxed) == 0;
+    }
+
+    bool DecrementItemCount(size_t n)
+    {
+        return count_.fetch_sub(n, std::memory_order_relaxed) == n;
+    }
+
+    void Start()
+    {
+        tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(mgr_));
+    }
+
+private:
+    DataT               data_;
+    std::atomic<size_t> count_{ 0 };
+
+    InputManager<D>&    mgr_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// InputManager
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename D>
+class InputManager :
+    public IContinuationTarget
+{
+private:
     // Select between thread-safe and non thread-safe implementations
     using TransactionQueueT = TransactionQueue<D::Policy::input_mode>;
+    using QueueEntryT = typename TransactionQueueT::QueueEntry;
+
     using ContinuationManagerT = ContinuationManager<D::Policy::propagation_mode>;
+    using AsyncWorkerT = AsyncWorker<D, D::Policy::input_mode>;
 
-    using QueueEntryT = typename TransactionQueueT::QueueEntry;
+    template <typename, EInputMode>
+    friend class AsyncWorker;
 
 public:
     using TurnT = typename D::TurnT;
     using Engine = typename D::Engine;
 
     InputManager() :
-        asyncWorker_( [this] { processAsyncQueue(); } )
-    {
-        asyncWorker_.detach();
-    }
+        asyncWorker_(*this)
+    {}
 
     template <typename F>
     void DoTransaction(TransactionFlagsT flags, F&& func)
@@ -556,7 +664,10 @@ class InputManager :
         if (waitingStatePtr != nullptr)
             waitingStatePtr->IncWaitCount();
 
-        asyncQueue_.push(AsyncItem{ flags, waitingStatePtr, std::forward<F>(func) } );
+        asyncWorker_.PushItem(AsyncItem{ flags, waitingStatePtr, std::forward<F>(func) });
+
+        if (asyncWorker_.IncrementItemCount(1))
+            asyncWorker_.Start();
     }
 
     template <typename R, typename V>
@@ -702,11 +813,20 @@ class InputManager :
 
         while (true)
         {
-            // Blocks if queue is empty
+            size_t popCount = 0;
+
             if (!skipPop)
-                asyncQueue_.pop(item);
+            {
+                // Blocks if queue is empty.
+                // This should never happen,
+                // and if (maybe due to some memory access internals), only briefly
+                asyncWorker_.PopItem(item);
+                popCount++;
+            }
             else
+            {
                 skipPop = false;
+            }
 
             // First try to merge to an existing synchronous item in the queue
             bool canMerge = (item.Flags & allow_merging) != 0;
@@ -745,8 +865,10 @@ class InputManager :
             {
                 uint extraCount = 0;
                 // Todo: Make configurable
-                while (extraCount < 512 && asyncQueue_.try_pop(item))
+                while (extraCount < 1024 && asyncWorker_.TryPopItem(item))
                 {
+                    ++popCount;
+
                     bool canMergeNext = (item.Flags & allow_merging) != 0;
                     if (canMergeNext)
                     {
@@ -786,10 +908,6 @@ class InputManager :
 
             continuationManager_.template DetachQueuedObservers<D>();
 
-            //printf("1\n");
-            //for (const auto& p : waitingStatePtrs)
-            //    printf("%08X\n", p.Get());
-
             // Has continuations? If so, status ptrs have to be passed on to
             // continuation transactions
             if (continuationManager_.HasContinuations())
@@ -800,10 +918,6 @@ class InputManager :
                 // More than 1 waiting state -> create collection from vector
                 if (waitingStatePtrs.size() > 1)
                 {
-  /*                  printf("2\n");
-                    for (const auto& p : waitingStatePtrs)
-                        printf("%08X\n", p.Get());*/
-
                     WaitingStatePtrT p
                     (
                         SharedWaitingStateCollection::Create(std::move(waitingStatePtrs))
@@ -839,14 +953,17 @@ class InputManager :
             }
 
             waitingStatePtrs.clear();
+
+            // Stop this task if the number of items has just been decremented zero.
+            // A new task will be started by the thread that increments the item count from zero.
+            if (asyncWorker_.DecrementItemCount(popCount))
+                break;
         }
     }
 
     TransactionQueueT       transactionQueue_;
     ContinuationManagerT    continuationManager_;
-
-    AsyncQueueT             asyncQueue_;
-    std::thread             asyncWorker_;
+    AsyncWorkerT            asyncWorker_;
 
     std::atomic<TurnIdT>    nextTurnId_{ 0 };
 

From 4538dd90f3f90dee8643d63124225779fbc99947 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 10 Aug 2014 00:26:52 +0200
Subject: [PATCH 21/75] Added event operation: Join.

Joins two streams A,B to tuple<A,B>. Values are buffered for each input slot and emitted once a tuple is complete.
---
 include/react/Event.h                   |  24 ++++-
 include/react/detail/graph/EventNodes.h | 129 ++++++++++++++++++++++++
 2 files changed, 151 insertions(+), 2 deletions(-)

diff --git a/include/react/Event.h b/include/react/Event.h
index e3f70f3e..777935e9 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -60,7 +60,6 @@ auto MakeEventSource()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// Note: Default template arguments are in forward declaration
 template
 <
     typename D,
@@ -77,7 +76,7 @@ auto Merge(const Events<D,TArg1>& arg1, const Events<D,TArgs>& ... args)
     using REACT_IMPL::EventOpNode;
 
     static_assert(sizeof...(TArgs) > 0,
-        "react::Merge requires at least 2 arguments.");
+        "Merge: 2+ arguments are required.");
 
     return TempEvents<D,E,TOp>(
         std::make_shared<EventOpNode<D,E,TOp>>(
@@ -427,6 +426,27 @@ auto Flatten(const Signal<D,Events<D,TInnerValue>>& outer)
             GetNodePtr(outer), GetNodePtr(outer.Value())));
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Join
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename D,
+    typename ... TArgs
+>
+auto Join(const Events<D,TArgs>& ... args)
+    -> Events<D, std::tuple<TArgs ...>>
+{
+    using REACT_IMPL::EventJoinNode;
+
+    static_assert(sizeof...(TArgs) > 1,
+        "Join: 2+ arguments are required.");
+
+    return Events<D, std::tuple<TArgs ...>>(
+        std::make_shared<EventJoinNode<D,TArgs...>>(
+            GetNodePtr(args) ...));
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Token
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 499cda24..850b36c2 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -898,6 +898,135 @@ class SyncedEventProcessingNode :
     DepHolderT  deps_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventJoinNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename D,
+    typename ... TValues
+>
+class EventJoinNode :
+    public EventStreamNode<D,std::tuple<TValues ...>>
+{
+    using Engine = typename EventJoinNode::Engine;
+    using TurnT = typename Engine::TurnT;
+
+public:
+    EventJoinNode(const std::shared_ptr<EventStreamNode<D,TValues>>& ... sources) :
+        EventJoinNode::EventStreamNode( ),
+        slots_( sources ... )
+    {
+        Engine::OnNodeCreate(*this);
+        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *sources));
+    }
+
+    ~EventJoinNode()
+    {
+        apply(
+            [this] (Slot<TValues>& ... slots) {
+                REACT_EXPAND_PACK(Engine::OnNodeDetach(*this, *slots.Source));
+            },
+            slots_);
+
+        Engine::OnNodeDestroy(*this);
+    }
+
+    virtual void Tick(void* turnPtr) override
+    {
+        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+
+        this->SetCurrentTurn(turn, true);
+
+        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
+            GetObjectId(*this), turn.Id()));
+
+        // Don't time if there is nothing to do
+        {// timer
+            size_t count = 0;
+            using TimerT = typename EventJoinNode::ScopedUpdateTimer;
+            TimerT scopedTimer( *this, count );
+
+            // Move events into buffers
+            apply(
+                [this, &turn] (Slot<TValues>& ... slots) {
+                    REACT_EXPAND_PACK(fetchBuffer(turn, slots));
+                },
+                slots_);
+
+            while (true)
+            {
+                bool isReady = true;
+
+                // All slots ready?
+                apply(
+                    [this,&isReady] (Slot<TValues>& ... slots) {
+                        // Todo: combine return values instead
+                        REACT_EXPAND_PACK(checkSlot(slots, isReady));
+                    },
+                    slots_);
+
+                if (!isReady)
+                    break;
+
+                // Pop values from buffers and emit tuple
+                apply(
+                    [this] (Slot<TValues>& ... slots) {
+                        this->events_.emplace_back(slots.Buffer.front() ...);
+                        REACT_EXPAND_PACK(slots.Buffer.pop_front());
+                    },
+                    slots_);
+            }
+
+            count = this->events_.size();
+
+        }// ~timer
+
+        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
+            GetObjectId(*this), turn.Id()));
+
+        if (! this->events_.empty())
+            Engine::OnNodePulse(*this, turn);
+        else
+            Engine::OnNodeIdlePulse(*this, turn);
+    }
+
+    virtual const char* GetNodeType() const override        { return "EventJoinNode"; }
+    virtual int         DependencyCount() const override    { return sizeof...(TValues); }
+
+private:
+    template <typename T>
+    struct Slot
+    {
+        Slot(const std::shared_ptr<EventStreamNode<D,T>>& src) :
+            Source( src )
+        {}
+
+        std::shared_ptr<EventStreamNode<D,T>>   Source;
+        std::deque<T>                           Buffer;
+    };
+
+    template <typename T>
+    static void fetchBuffer(TurnT& turn, Slot<T>& slot)
+    {
+        slot.Source->SetCurrentTurn(turn);
+
+        slot.Buffer.insert(
+            slot.Buffer.end(),
+            slot.Source->Events().begin(),
+            slot.Source->Events().end());
+    }
+
+    template <typename T>
+    static void checkSlot(Slot<T>& slot, bool& isReady)
+    {
+        auto t = isReady && !slot.Buffer.empty();
+        isReady = t;
+    }
+
+    std::tuple<Slot<TValues>...>    slots_;
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_EVENTNODES_H_INCLUDED
\ No newline at end of file

From bad1c7940f329e23b935b1f40ef1d2e76068cd51 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 12 Jan 2015 17:54:34 +0100
Subject: [PATCH 22/75] Fixed duplicated symbols for domain initializer.
 (Thanks to Dominik for reporting the bug.)

---
 include/react/Domain.h | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/include/react/Domain.h b/include/react/Domain.h
index 8bbf6f00..e27c2514 100644
--- a/include/react/Domain.h
+++ b/include/react/Domain.h
@@ -428,7 +428,16 @@ void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& fu
 #define REACTIVE_DOMAIN(name, ...)                                                          \
     struct name :                                                                           \
         public REACT_IMPL::DomainBase<name, REACT_IMPL::DomainPolicy< __VA_ARGS__ >> {};    \
-    REACT_IMPL::DomainInitializer<name> name ## _initializer_;
+    static REACT_IMPL::DomainInitializer<name> name ## _initializer_;
+
+/*
+    A brief reminder why the domain initializer is here:
+    Each domain has a couple of singletons (debug log, engine, input manager) which are
+    currently implemented as meyer singletons. From what I understand, these are thread-safe
+    in C++11, but not all compilers implement that yet. That's why a static initializer has
+    been added to make sure singleton creation happens before any multi-threaded access.
+    This implemenation is obviously inconsequential.
+ */
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Define type aliases for given domain

From 412127d0da37f3fafe4d17c07dd51509b737b86e Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 12 Jan 2015 17:55:04 +0100
Subject: [PATCH 23/75] Cleanup/refactoring.

---
 include/react/Event.h                  |  2 +-
 include/react/Signal.h                 |  4 ++--
 include/react/TypeTraits.h             | 32 ++++++++++++++++++++++----
 include/react/detail/graph/GraphBase.h |  6 ++++-
 tests/src/EventStreamTest.h            |  2 +-
 tests/src/OperationsTest.h             |  2 +-
 6 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/include/react/Event.h b/include/react/Event.h
index 777935e9..2c286809 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -348,7 +348,7 @@ auto Transform(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& d
 /// Process
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 using REACT_IMPL::EventRange;
-using REACT_IMPL::EventInserter;
+using REACT_IMPL::EventEmitter;
 
 template
 <
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 936874b4..7f211392 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -933,7 +933,7 @@ bool Equals(const Signal<D,L>& lhs, const Signal<D,R>& rhs)
                 REACT_IMPL::Identity<decltype(obj)>::Type::ValueT& r)                       \
             {                                                                               \
                 using T = decltype(r.name);                                                 \
-                using S = REACT_MSVC_NO_TYPENAME REACT::RemoveInput<T>::Type;               \
+                using S = REACT_MSVC_NO_TYPENAME REACT::DecayInput<T>::Type;                \
                 return static_cast<S>(r.name);                                              \
             }))
 
@@ -946,7 +946,7 @@ bool Equals(const Signal<D,L>& lhs, const Signal<D,R>& rhs)
             {                                                                               \
                 assert(r != nullptr);                                                       \
                 using T = decltype(r->name);                                                \
-                using S = REACT_MSVC_NO_TYPENAME REACT::RemoveInput<T>::Type;               \
+                using S = REACT_MSVC_NO_TYPENAME REACT::DecayInput<T>::Type;                \
                 return static_cast<S>(r->name);                                             \
             }))
 
diff --git a/include/react/TypeTraits.h b/include/react/TypeTraits.h
index 7141ac14..c6b6b7dd 100644
--- a/include/react/TypeTraits.h
+++ b/include/react/TypeTraits.h
@@ -94,6 +94,30 @@ struct IsContinuation { static const bool value = false; };
 template <typename D, typename D2>
 struct IsContinuation<Continuation<D,D2>> { static const bool value = true; };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// IsObservable
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct IsObservable { static const bool value = false; };
+
+template <typename D, typename T>
+struct IsObservable<Signal<D,T>> { static const bool value = true; };
+
+template <typename D, typename T>
+struct IsObservable<VarSignal<D,T>> { static const bool value = true; };
+
+template <typename D, typename T, typename TOp>
+struct IsObservable<TempSignal<D,T,TOp>> { static const bool value = true; };
+
+template <typename D, typename T>
+struct IsObservable<Events<D,T>> { static const bool value = true; };
+
+template <typename D, typename T>
+struct IsObservable<EventSource<D,T>> { static const bool value = true; };
+
+template <typename D, typename T, typename TOp>
+struct IsObservable<TempEvents<D,T,TOp>> { static const bool value = true; };
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsReactive
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -128,16 +152,16 @@ template <typename D, typename D2>
 struct IsReactive<Continuation<D,D2>> { static const bool value = true; };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// RemoveInput
+/// DecayInput
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-struct RemoveInput { using Type = T; };
+struct DecayInput { using Type = T; };
 
 template <typename D, typename T>
-struct RemoveInput<VarSignal<D,T>> { using Type = Signal<D,T>; };
+struct DecayInput<VarSignal<D,T>> { using Type = Signal<D,T>; };
 
 template <typename D, typename T>
-struct RemoveInput<EventSource<D,T>> { using Type = Events<D,T>; };
+struct DecayInput<EventSource<D,T>> { using Type = Events<D,T>; };
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 2adf8160..b7d79d27 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -255,8 +255,12 @@ class EventRange
     using const_iterator = typename std::vector<E>::const_iterator;
     using size_type = typename std::vector<E>::size_type;
 
+    // Copy ctor
     EventRange(const EventRange&) = default;
 
+    // Copy assignment
+    EventRange& operator=(const EventRange&) = default;
+
     const_iterator begin() const    { return data_.begin(); }
     const_iterator end() const      { return data_.end(); }
 
@@ -272,7 +276,7 @@ class EventRange
 };
 
 template <typename E>
-using EventInserter = std::back_insert_iterator<std::vector<E>>;
+using EventEmitter = std::back_insert_iterator<std::vector<E>>;
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
diff --git a/tests/src/EventStreamTest.h b/tests/src/EventStreamTest.h
index 39e2479d..bb2efce4 100644
--- a/tests/src/EventStreamTest.h
+++ b/tests/src/EventStreamTest.h
@@ -285,7 +285,7 @@ TYPED_TEST_P(EventStreamTest, EventProcess)
     int callCount = 0;
 
     auto processed = Process<float>(merged,
-        [&] (EventRange<int> range, EventInserter<float> out)
+        [&] (EventRange<int> range, EventEmitter<float> out)
         {
             for (const auto& e : range)
             {
diff --git a/tests/src/OperationsTest.h b/tests/src/OperationsTest.h
index 77e8c399..5ef9cc3d 100644
--- a/tests/src/OperationsTest.h
+++ b/tests/src/OperationsTest.h
@@ -911,7 +911,7 @@ TYPED_TEST_P(OperationsTest, SyncedEventProcess1)
 
     auto processed = Process<float>(merged,
         With(mult),
-        [&] (EventRange<int> range, EventInserter<float> out, int mult)
+        [&] (EventRange<int> range, EventEmitter<float> out, int mult)
         {
             for (const auto& e : range)
             {

From 2f1cb0ac85a3aa4fd8c908832634b85e68aa20fb Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 16 Feb 2015 20:12:28 +0100
Subject: [PATCH 24/75] Fixed #8.

---
 include/react/detail/IReactiveEngine.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/react/detail/IReactiveEngine.h b/include/react/detail/IReactiveEngine.h
index 33aaf076..9a422cb8 100644
--- a/include/react/detail/IReactiveEngine.h
+++ b/include/react/detail/IReactiveEngine.h
@@ -72,7 +72,7 @@ struct EngineInterface
 
     static void OnTurnAdmissionStart(TurnT& turn)
     {
-        Instance().OnTurnAdmissionEnd(turn);
+        Instance().OnTurnAdmissionStart(turn);
     }
 
     static void OnTurnAdmissionEnd(TurnT& turn)

From 1f6ddb75ccba2304d7fdfeb36e398fc276d7b89b Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 23 Mar 2015 11:44:12 +0100
Subject: [PATCH 25/75] Fixed #9

---
 include/react/common/Timing.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/react/common/Timing.h b/include/react/common/Timing.h
index 08f72892..3775661d 100644
--- a/include/react/common/Timing.h
+++ b/include/react/common/Timing.h
@@ -189,7 +189,11 @@ class ConditionalTimer<threshold,true>
 private:
     // Only measure once
     bool shouldMeasure_ = true;
-    bool isThresholdExceeded_ = false;
+
+    // Until we have measured, assume the threshold is exceeded.
+    // The cost of initially not parallelizing what should be parallelized is much higher
+    // than for the other way around.
+    bool isThresholdExceeded_ = true;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/

From 0ca831161895a04d7965144ddc35d16f3b3c1f24 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 12 Jun 2016 15:23:43 +0200
Subject: [PATCH 26/75] Update to VS2015.

---
 project/msvc/CppReact.vcxproj                     | 10 +++++-----
 project/msvc/CppReactBenchmark.vcxproj            | 10 +++++-----
 project/msvc/CppReactExample.vcxproj              | 10 +++++-----
 project/msvc/CppReactTest.vcxproj                 | 10 +++++-----
 project/msvc/Example_BasicAlgorithms.vcxproj      | 10 +++++-----
 project/msvc/Example_BasicComposition.vcxproj     | 10 +++++-----
 project/msvc/Example_BasicEvents.vcxproj          | 10 +++++-----
 project/msvc/Example_BasicObservers.vcxproj       | 10 +++++-----
 project/msvc/Example_BasicReactors.vcxproj        | 10 +++++-----
 project/msvc/Example_BasicSignals.vcxproj         | 10 +++++-----
 project/msvc/Example_BasicSynchronization.vcxproj | 10 +++++-----
 11 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 16ae1f97..d9782c0d 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/CppReactBenchmark.vcxproj b/project/msvc/CppReactBenchmark.vcxproj
index 7613239a..a57e4b20 100644
--- a/project/msvc/CppReactBenchmark.vcxproj
+++ b/project/msvc/CppReactBenchmark.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/CppReactExample.vcxproj b/project/msvc/CppReactExample.vcxproj
index 323c777f..34a714e6 100644
--- a/project/msvc/CppReactExample.vcxproj
+++ b/project/msvc/CppReactExample.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -27,26 +27,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/CppReactTest.vcxproj b/project/msvc/CppReactTest.vcxproj
index 7b1cb65f..5c2878a4 100644
--- a/project/msvc/CppReactTest.vcxproj
+++ b/project/msvc/CppReactTest.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicAlgorithms.vcxproj b/project/msvc/Example_BasicAlgorithms.vcxproj
index eeffca5a..f77233e6 100644
--- a/project/msvc/Example_BasicAlgorithms.vcxproj
+++ b/project/msvc/Example_BasicAlgorithms.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicComposition.vcxproj b/project/msvc/Example_BasicComposition.vcxproj
index 01d26c88..43101fb2 100644
--- a/project/msvc/Example_BasicComposition.vcxproj
+++ b/project/msvc/Example_BasicComposition.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicEvents.vcxproj b/project/msvc/Example_BasicEvents.vcxproj
index d5d13295..07370926 100644
--- a/project/msvc/Example_BasicEvents.vcxproj
+++ b/project/msvc/Example_BasicEvents.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicObservers.vcxproj b/project/msvc/Example_BasicObservers.vcxproj
index 9fa37b8c..7e27da42 100644
--- a/project/msvc/Example_BasicObservers.vcxproj
+++ b/project/msvc/Example_BasicObservers.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicReactors.vcxproj b/project/msvc/Example_BasicReactors.vcxproj
index 07701d98..ba7b1dad 100644
--- a/project/msvc/Example_BasicReactors.vcxproj
+++ b/project/msvc/Example_BasicReactors.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicSignals.vcxproj b/project/msvc/Example_BasicSignals.vcxproj
index e090dd8a..556b2ad0 100644
--- a/project/msvc/Example_BasicSignals.vcxproj
+++ b/project/msvc/Example_BasicSignals.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicSynchronization.vcxproj b/project/msvc/Example_BasicSynchronization.vcxproj
index 2b2edec4..faa0ccfb 100644
--- a/project/msvc/Example_BasicSynchronization.vcxproj
+++ b/project/msvc/Example_BasicSynchronization.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>

From 872d6d34a5eacac966ac5bb1058f05c0d4d5e0ec Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 12 Jun 2016 15:24:33 +0200
Subject: [PATCH 27/75] WIP refactor

---
 benchmarks/src/Main.cpp                  |  15 +-
 include/react/Event.h                    | 495 ++---------------
 include/react/Observer.h                 |   8 +-
 include/react/Signal.h                   | 652 +----------------------
 include/react/TypeTraits.h               | 113 ++--
 include/react/detail/graph/SignalNodes.h |  39 +-
 6 files changed, 135 insertions(+), 1187 deletions(-)

diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index eb47f33f..00284776 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -37,6 +37,11 @@ REACTIVE_DOMAIN(ToposortDomain, parallel, ToposortEngine)
 REACTIVE_DOMAIN(PulsecountDomain, parallel, PulsecountEngine)
 REACTIVE_DOMAIN(SubtreeDomain, parallel, SubtreeEngine)
 
+REACTIVE_DOMAIN(ToposortSTDomainConc, sequential_concurrent, ToposortEngine)
+REACTIVE_DOMAIN(ToposortDomainConc, parallel_concurrent, ToposortEngine)
+REACTIVE_DOMAIN(PulsecountDomainConc, parallel_concurrent, PulsecountEngine)
+REACTIVE_DOMAIN(SubtreeDomainConc, parallel_concurrent, SubtreeEngine)
+
 void runBenchmarkGrid(std::ostream& out)
 {
     RUN_BENCHMARK(out, 5, Benchmark_Grid, BenchmarkParams_Grid(20, 10000),
@@ -130,7 +135,7 @@ void runBenchmarkLifeSim(std::ostream& out)
     //    SourceSetDomain, PulsecountDomain);
 
     RUN_BENCHMARK(out, 1, Benchmark_LifeSim, BenchmarkParams_LifeSim(100, 15, 10000),
-        ToposortSTDomain, ToposortDomain, PulsecountDomain);
+        ToposortSTDomainConc, ToposortDomainConc, PulsecountDomainConc);
 
     //RUN_BENCHMARK(out, 3, Benchmark_LifeSim, BenchmarkParams_LifeSim(100, 50, 100),
     //    PulsecountDomain, PulsecountDomain);
@@ -216,9 +221,9 @@ void debugBenchmarks()
 
 void profileBenchmark()
 {
-    RUN_BENCHMARK(std::cout, 1, Benchmark_Grid, BenchmarkParams_Grid(30, 10000),
-        ToposortSTDomain);
-        //ToposortSTDomain, ToposortDomain, PulsecountDomain, SubtreeDomain);
+    RUN_BENCHMARK(std::cout, 3, Benchmark_Grid, BenchmarkParams_Grid(100, 10000),
+        //SubtreeDomain);
+        ToposortSTDomain, ToposortDomain, PulsecountDomain, SubtreeDomain);
 
     //RUN_BENCHMARK(std::cout, 1, Benchmark_Grid, BenchmarkParams_Grid(30, 10000),
         //SourceSetDomain);
@@ -228,7 +233,7 @@ void profileBenchmark()
         //ToposortSTDomain, ToposortDomain, PulsecountDomain, SubtreeDomain);
 
     //RUN_BENCHMARK(std::cout, 1, Benchmark_LifeSim, BenchmarkParams_LifeSim(100, 15, 10000),
-        //ToposortSTDomain);
+        //ToposortSTDomainConc);
 }
 
 } // ~anonymous namespace 
diff --git a/include/react/Event.h b/include/react/Event.h
index 2c286809..8ca754c2 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -25,36 +25,28 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename E>
+template <typename E>
 class Events;
 
-template <typename D, typename E>
+template <typename E>
 class EventSource;
 
-template <typename D, typename E, typename TOp>
-class TempEvents;
-
 enum class Token;
 
-template <typename D, typename S>
+template <typename S>
 class Signal;
 
-template <typename D, typename ... TValues>
-class SignalPack;
-
 using REACT_IMPL::WeightHint;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// MakeEventSource
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename E = Token>
-auto MakeEventSource()
-    -> EventSource<D,E>
+template <typename E = Token>
+auto MakeEventSource() -> EventSource<E>
 {
     using REACT_IMPL::EventSourceNode;
 
-    return EventSource<D,E>(
-        std::make_shared<EventSourceNode<D,E>>());
+    return EventSource<E>(std::make_shared<EventSourceNode<E>>());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -62,174 +54,49 @@ auto MakeEventSource()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename TArg1,
     typename ... TArgs,
-    typename E = TArg1,
-    typename TOp = REACT_IMPL::EventMergeOp<E,
-        REACT_IMPL::EventStreamNodePtrT<D,TArg1>,
-        REACT_IMPL::EventStreamNodePtrT<D,TArgs> ...>
+    typename E = TArg1
 >
-auto Merge(const Events<D,TArg1>& arg1, const Events<D,TArgs>& ... args)
-    -> TempEvents<D,E,TOp>
+auto Merge(const Events<TArg1>& arg1, const Events<TArgs>& ... args) -> Events<E>
 {
     using REACT_IMPL::EventOpNode;
 
-    static_assert(sizeof...(TArgs) > 0,
-        "Merge: 2+ arguments are required.");
+    static_assert(sizeof...(TArgs) > 0, "Merge: 2+ arguments are required.");
 
-    return TempEvents<D,E,TOp>(
-        std::make_shared<EventOpNode<D,E,TOp>>(
+    return Events<E>(
+        std::make_shared<EventMergeNode<E>>(
             GetNodePtr(arg1), GetNodePtr(args) ...));
 }
 
-template
-<
-    typename TLeftEvents,
-    typename TRightEvents,
-    typename D = typename TLeftEvents::DomainT,
-    typename TLeftVal = typename TLeftEvents::ValueT,
-    typename TRightVal = typename TRightEvents::ValueT,
-    typename E = TLeftVal,
-    typename TOp = REACT_IMPL::EventMergeOp<E,
-        REACT_IMPL::EventStreamNodePtrT<D,TLeftVal>,
-        REACT_IMPL::EventStreamNodePtrT<D,TRightVal>>,
-    class = typename std::enable_if<
-        IsEvent<TLeftEvents>::value>::type,
-    class = typename std::enable_if<
-        IsEvent<TRightEvents>::value>::type
->
-auto operator|(const TLeftEvents& lhs, const TRightEvents& rhs)
-    -> TempEvents<D,E,TOp>
-{
-    using REACT_IMPL::EventOpNode;
-
-    return TempEvents<D,E,TOp>(
-        std::make_shared<EventOpNode<D,E,TOp>>(
-            GetNodePtr(lhs), GetNodePtr(rhs)));
-}
-
-template
-<
-    typename D,
-    typename TLeftVal,
-    typename TLeftOp,
-    typename TRightVal,
-    typename TRightOp,
-    typename E = TLeftVal,
-    typename TOp = REACT_IMPL::EventMergeOp<E,TLeftOp,TRightOp>
->
-auto operator|(TempEvents<D,TLeftVal,TLeftOp>&& lhs, TempEvents<D,TRightVal,TRightOp>&& rhs)
-    -> TempEvents<D,E,TOp>
-{
-    using REACT_IMPL::EventOpNode;
-
-    return TempEvents<D,E,TOp>(
-        std::make_shared<EventOpNode<D,E,TOp>>(
-            lhs.StealOp(), rhs.StealOp()));
-}
-
-template
-<
-    typename D,
-    typename TLeftVal,
-    typename TLeftOp,
-    typename TRightEvents,
-    typename TRightVal = typename TRightEvents::ValueT,
-    typename E = TLeftVal,
-    typename TOp = REACT_IMPL::EventMergeOp<E,
-        TLeftOp,
-        REACT_IMPL::EventStreamNodePtrT<D,TRightVal>>,
-    class = typename std::enable_if<
-        IsEvent<TRightEvents>::value>::type
->
-auto operator|(TempEvents<D,TLeftVal,TLeftOp>&& lhs, const TRightEvents& rhs)
-    -> TempEvents<D,E,TOp>
-{
-    using REACT_IMPL::EventOpNode;
-
-    return TempEvents<D,E,TOp>(
-        std::make_shared<EventOpNode<D,E,TOp>>(
-            lhs.StealOp(), GetNodePtr(rhs)));
-}
-
-template
-<
-    typename TLeftEvents,
-    typename D,
-    typename TRightVal,
-    typename TRightOp,
-    typename TLeftVal = typename TLeftEvents::ValueT,
-    typename E = TLeftVal,
-    typename TOp = REACT_IMPL::EventMergeOp<E,
-        REACT_IMPL::EventStreamNodePtrT<D,TRightVal>,
-        TRightOp>,
-    class = typename std::enable_if<
-        IsEvent<TLeftEvents>::value>::type
->
-auto operator|(const TLeftEvents& lhs, TempEvents<D,TRightVal,TRightOp>&& rhs)
-    -> TempEvents<D,E,TOp>
-{
-    using REACT_IMPL::EventOpNode;
-
-    return TempEvents<D,E,TOp>(
-        std::make_shared<EventOpNode<D,E,TOp>>(
-            GetNodePtr(lhs), rhs.StealOp()));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename E,
     typename FIn,
-    typename F = typename std::decay<FIn>::type,
-    typename TOp = REACT_IMPL::EventFilterOp<E,F,
-        REACT_IMPL::EventStreamNodePtrT<D,E>>
+    typename F = typename std::decay<FIn>::type
 >
-auto Filter(const Events<D,E>& src, FIn&& filter)
-    -> TempEvents<D,E,TOp>
+auto Filter(const Events<E>& src, FIn&& filter) -> Events<E>
 {
     using REACT_IMPL::EventOpNode;
 
-    return TempEvents<D,E,TOp>(
-        std::make_shared<EventOpNode<D,E,TOp>>(
+    return Events<E>(
+        std::make_shared<EventOpNode<E>>(
             std::forward<FIn>(filter), GetNodePtr(src)));
 }
 
-template
-<
-    typename D,
-    typename E,
-    typename TOpIn,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type,
-    typename TOpOut = REACT_IMPL::EventFilterOp<E,F,TOpIn>
->
-auto Filter(TempEvents<D,E,TOpIn>&& src, FIn&& filter)
-    -> TempEvents<D,E,TOpOut>
-{
-    using REACT_IMPL::EventOpNode;
-
-    return TempEvents<D,E,TOpOut>(
-        std::make_shared<EventOpNode<D,E,TOpOut>>(
-            std::forward<FIn>(filter), src.StealOp()));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename E,
     typename FIn,
     typename ... TDepValues
 >
-auto Filter(const Events<D,E>& source, const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Events<D,E>
+auto Filter(const Events<E>& source, const SignalPack<TDepValues...>& depPack, FIn&& func) -> Events<E>
 {
     using REACT_IMPL::SyncedEventFilterNode;
 
@@ -237,20 +104,20 @@ auto Filter(const Events<D,E>& source, const SignalPack<D,TDepValues...>& depPac
 
     struct NodeBuilder_
     {
-        NodeBuilder_(const Events<D,E>& source, FIn&& func) :
+        NodeBuilder_(const Events<E>& source, FIn&& func) :
             MySource( source ),
             MyFunc( std::forward<FIn>(func) )
         {}
 
         auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Events<D,E>
+            -> Events<E>
         {
-            return Events<D,E>(
+            return Events<E>(
                 std::make_shared<SyncedEventFilterNode<D,E,F,TDepValues ...>>(
                      GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
         }
 
-        const Events<D,E>&      MySource;
+        const Events<E>&      MySource;
         FIn                     MyFunc;
     };
 
@@ -264,57 +131,31 @@ auto Filter(const Events<D,E>& source, const SignalPack<D,TDepValues...>& depPac
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename TIn,
     typename FIn,
     typename F = typename std::decay<FIn>::type,
-    typename TOut = typename std::result_of<F(TIn)>::type,
-    typename TOp = REACT_IMPL::EventTransformOp<TIn,F,
-        REACT_IMPL::EventStreamNodePtrT<D,TIn>>
+    typename TOut = typename std::result_of<F(TIn)>::type
 >
-auto Transform(const Events<D,TIn>& src, FIn&& func)
-    -> TempEvents<D,TOut,TOp>
+auto Transform(const Events<TIn>& src, FIn&& func) -> Events<TOut>
 {
     using REACT_IMPL::EventOpNode;
 
-    return TempEvents<D,TOut,TOp>(
-        std::make_shared<EventOpNode<D,TOut,TOp>>(
+    return Events<TOut>(
+        std::make_shared<EventOpNode<TOut>>(
             std::forward<FIn>(func), GetNodePtr(src)));
 }
 
-template
-<
-    typename D,
-    typename TIn,
-    typename TOpIn,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type,
-    typename TOut = typename std::result_of<F(TIn)>::type,
-    typename TOpOut = REACT_IMPL::EventTransformOp<TIn,F,TOpIn>
->
-auto Transform(TempEvents<D,TIn,TOpIn>&& src, FIn&& func)
-    -> TempEvents<D,TOut,TOpOut>
-{
-    using REACT_IMPL::EventOpNode;
-
-    return TempEvents<D,TOut,TOpOut>(
-        std::make_shared<EventOpNode<D,TOut,TOpOut>>(
-            std::forward<FIn>(func), src.StealOp()));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Transform - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename TIn,
     typename FIn,
     typename ... TDepValues,
     typename TOut = typename std::result_of<FIn(TIn,TDepValues...)>::type
 >
-auto Transform(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Events<D,TOut>
+auto Transform(const Events<TIn>& source, FIn&& func, const Signal<TDepValues>& ... deps) -> Events<TOut>
 {
     using REACT_IMPL::SyncedEventTransformNode;
 
@@ -322,20 +163,20 @@ auto Transform(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& d
 
     struct NodeBuilder_
     {
-        NodeBuilder_(const Events<D,TIn>& source, FIn&& func) :
+        NodeBuilder_(const Events<TIn>& source, FIn&& func) :
             MySource( source ),
             MyFunc( std::forward<FIn>(func) )
         {}
 
         auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Events<D,TOut>
+            -> Events<TOut>
         {
-            return Events<D,TOut>(
+            return Events<TOut>(
                 std::make_shared<SyncedEventTransformNode<D,TIn,TOut,F,TDepValues ...>>(
                      GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
         }
 
-        const Events<D,TIn>&    MySource;
+        const Events<TIn>&    MySource;
         FIn                     MyFunc;
     };
 
@@ -353,17 +194,15 @@ using REACT_IMPL::EventEmitter;
 template
 <
     typename TOut,
-    typename D,
     typename TIn,
     typename FIn,
     typename F = typename std::decay<FIn>::type
 >
-auto Process(const Events<D,TIn>& src, FIn&& func)
-    -> Events<D,TOut>
+auto Process(const Events<TIn>& src, FIn&& func) -> Events<TOut>
 {
     using REACT_IMPL::EventProcessingNode;
 
-    return Events<D,TOut>(
+    return Events<TOut>(
         std::make_shared<EventProcessingNode<D,TIn,TOut,F>>(
             GetNodePtr(src), std::forward<FIn>(func)));
 }
@@ -374,13 +213,11 @@ auto Process(const Events<D,TIn>& src, FIn&& func)
 template
 <
     typename TOut,
-    typename D,
     typename TIn,
     typename FIn,
     typename ... TDepValues
 >
-auto Process(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Events<D,TOut>
+auto Process(const Events<TIn>& source, const SignalPack<D,TDepValues...>& depPack, FIn&& func) -> Events<TOut>
 {
     using REACT_IMPL::SyncedEventProcessingNode;
 
@@ -388,20 +225,20 @@ auto Process(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& dep
 
     struct NodeBuilder_
     {
-        NodeBuilder_(const Events<D,TIn>& source, FIn&& func) :
+        NodeBuilder_(const Events<TIn>& source, FIn&& func) :
             MySource( source ),
             MyFunc( std::forward<FIn>(func) )
         {}
 
         auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Events<D,TOut>
+            -> Events<TOut>
         {
-            return Events<D,TOut>(
+            return Events<TOut>(
                 std::make_shared<SyncedEventProcessingNode<D,TIn,TOut,F,TDepValues ...>>(
                      GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
         }
 
-        const Events<D,TIn>&    MySource;
+        const Events<TIn>&    MySource;
         FIn                     MyFunc;
     };
 
@@ -413,37 +250,26 @@ auto Process(const Events<D,TIn>& source, const SignalPack<D,TDepValues...>& dep
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TInnerValue
->
-auto Flatten(const Signal<D,Events<D,TInnerValue>>& outer)
-    -> Events<D,TInnerValue>
+template <typename TInnerValue>
+auto Flatten(const Signal<Events<TInnerValue>>& outer) -> Events<TInnerValue>
 {
-    return Events<D,TInnerValue>(
-        std::make_shared<REACT_IMPL::EventFlattenNode<D, Events<D,TInnerValue>, TInnerValue>>(
+    return Events<TInnerValue>(
+        std::make_shared<REACT_IMPL::EventFlattenNode<Events<TInnerValue>, TInnerValue>>(
             GetNodePtr(outer), GetNodePtr(outer.Value())));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename ... TArgs
->
-auto Join(const Events<D,TArgs>& ... args)
-    -> Events<D, std::tuple<TArgs ...>>
+template <typename ... TArgs>
+auto Join(const Events<TArgs>& ... args) -> Events<std::tuple<TArgs ...>>
 {
     using REACT_IMPL::EventJoinNode;
 
-    static_assert(sizeof...(TArgs) > 1,
-        "Join: 2+ arguments are required.");
+    static_assert(sizeof...(TArgs) > 1, "Join: 2+ arguments are required.");
 
-    return Events<D, std::tuple<TArgs ...>>(
-        std::make_shared<EventJoinNode<D,TArgs...>>(
+    return Events< std::tuple<TArgs ...>>(
+        std::make_shared<EventJoinNode<TArgs...>>(
             GetNodePtr(args) ...));
 }
 
@@ -459,8 +285,7 @@ struct Tokenizer
 };
 
 template <typename TEvents>
-auto Tokenize(TEvents&& source)
-    -> decltype(Transform(source, Tokenizer{}))
+auto Tokenize(TEvents&& source) -> decltype(Transform(source, Tokenizer{}))
 {
     return Transform(source, Tokenizer{});
 }
@@ -468,15 +293,11 @@ auto Tokenize(TEvents&& source)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Events
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E = Token
->
-class Events : public REACT_IMPL::EventStreamBase<D,E>
+template <typename E = Token>
+class Events : public REACT_IMPL::EventStreamBase<E>
 {
 private:
-    using NodeT     = REACT_IMPL::EventStreamNode<D,E>;
+    using NodeT     = REACT_IMPL::EventStreamNode<E>;
     using NodePtrT  = std::shared_ptr<NodeT>;
 
 public:
@@ -551,99 +372,11 @@ class Events : public REACT_IMPL::EventStreamBase<D,E>
     }
 };
 
-// Specialize for references
-template
-<
-    typename D,
-    typename E
->
-class Events<D,E&> : public REACT_IMPL::EventStreamBase<D,std::reference_wrapper<E>>
-{
-private:
-    using NodeT     = REACT_IMPL::EventStreamNode<D,std::reference_wrapper<E>>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
-
-public:
-    using ValueT = E;
-
-    // Default ctor
-    Events() = default;
-
-    // Copy ctor
-    Events(const Events&) = default;
-
-    // Move ctor
-    Events(Events&& other) :
-        Events::EventStreamBase( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit Events(NodePtrT&& nodePtr) :
-        Events::EventStreamBase( std::move(nodePtr) )
-    {}
-
-    // Copy assignment
-    Events& operator=(const Events&) = default;
-
-    // Move assignment
-    Events& operator=(Events&& other)
-    {
-        Events::EventStreamBase::operator=( std::move(other) );
-        return *this;
-    }
-
-    bool Equals(const Events& other) const
-    {
-        return Events::EventStreamBase::Equals(other);
-    }
-
-    bool IsValid() const
-    {
-        return Events::EventStreamBase::IsValid();
-    }
-
-    void SetWeightHint(WeightHint weight)
-    {
-        Events::EventStreamBase::SetWeightHint(weight);
-    }
-
-    auto Tokenize() const
-        -> decltype(REACT::Tokenize(std::declval<Events>()))
-    {
-        return REACT::Tokenize(*this);
-    }
-
-    template <typename ... TArgs>
-    auto Merge(TArgs&& ... args)
-        -> decltype(REACT::Merge(std::declval<Events>(), std::forward<TArgs>(args) ...))
-    {
-        return REACT::Merge(*this, std::forward<TArgs>(args) ...);
-    }
-
-    template <typename F>
-    auto Filter(F&& f) const
-        -> decltype(REACT::Filter(std::declval<Events>(), std::forward<F>(f)))
-    {
-        return REACT::Filter(*this, std::forward<F>(f));
-    }
-
-    template <typename F>
-    auto Transform(F&& f) const
-        -> decltype(REACT::Transform(std::declval<Events>(), std::forward<F>(f)))
-    {
-        return REACT::Transform(*this, std::forward<F>(f));
-    }
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSource
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E = Token
->
-class EventSource : public Events<D,E>
+template <typename E = Token>
+class EventSource : public Events<E>
 {
 private:
     using NodeT     = REACT_IMPL::EventSourceNode<D,E>;
@@ -710,134 +443,12 @@ class EventSource : public Events<D,E>
     }
 };
 
-// Specialize for references
-template
-<
-    typename D,
-    typename E
->
-class EventSource<D,E&> : public Events<D,std::reference_wrapper<E>>
-{
-private:
-    using NodeT     = REACT_IMPL::EventSourceNode<D,std::reference_wrapper<E>>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
-
-public:
-    // Default ctor
-    EventSource() = default;
-
-    // Copy ctor
-    EventSource(const EventSource&) = default;
-
-    // Move ctor
-    EventSource(EventSource&& other) :
-        EventSource::Events( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit EventSource(NodePtrT&& nodePtr) :
-        EventSource::Events( std::move(nodePtr) )
-    {}
-
-    // Copy assignment
-    EventSource& operator=(const EventSource&) = default;
-
-    // Move assignment
-    EventSource& operator=(EventSource&& other)
-    {
-        EventSource::Events::operator=( std::move(other) );
-        return *this;
-    }
-
-    // Explicit emit
-    void Emit(std::reference_wrapper<E> e) const        { EventSource::EventStreamBase::emit(e); }
-
-    // Function object style
-    void operator()(std::reference_wrapper<E> e) const  { EventSource::EventStreamBase::emit(e); }
-
-    // Stream style
-    const EventSource& operator<<(std::reference_wrapper<E> e) const
-    {
-        EventSource::EventStreamBase::emit(e);
-        return *this;
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TempEvents
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E,
-    typename TOp
->
-class TempEvents : public Events<D,E>
-{
-protected:
-    using NodeT     = REACT_IMPL::EventOpNode<D,E,TOp>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
-
-public:
-    // Default ctor
-    TempEvents() = default;
-
-    // Copy ctor
-    TempEvents(const TempEvents&) = default;
-
-    // Move ctor
-    TempEvents(TempEvents&& other) :
-        TempEvents::Events( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit TempEvents(NodePtrT&& nodePtr) :
-        TempEvents::Events( std::move(nodePtr) )
-    {}
-
-    // Copy assignment
-    TempEvents& operator=(const TempEvents&) = default;
-
-    // Move assignment
-    TempEvents& operator=(TempEvents&& other)
-    {
-        TempEvents::EventStreamBase::operator=( std::move(other) );
-        return *this;
-    }
-
-    TOp StealOp()
-    {
-        return std::move(reinterpret_cast<NodeT*>(this->ptr_.get())->StealOp());
-    }
-
-    template <typename ... TArgs>
-    auto Merge(TArgs&& ... args)
-        -> decltype(REACT::Merge(std::declval<TempEvents>(), std::forward<TArgs>(args) ...))
-    {
-        return REACT::Merge(*this, std::forward<TArgs>(args) ...);
-    }
-
-    template <typename F>
-    auto Filter(F&& f) const
-        -> decltype(REACT::Filter(std::declval<TempEvents>(), std::forward<F>(f)))
-    {
-        return REACT::Filter(*this, std::forward<F>(f));
-    }
-
-    template <typename F>
-    auto Transform(F&& f) const
-        -> decltype(REACT::Transform(std::declval<TempEvents>(), std::forward<F>(f)))
-    {
-        return REACT::Transform(*this, std::forward<F>(f));
-    }
-};
-
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-template <typename D, typename L, typename R>
-bool Equals(const Events<D,L>& lhs, const Events<D,R>& rhs)
+template <typename L, typename R>
+bool Equals(const Events<L>& lhs, const Events<R>& rhs)
 {
     return lhs.Equals(rhs);
 }
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 45fd78a1..c9d986dc 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -24,13 +24,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename S>
 class Signal;
 
-template <typename D, typename ... TValues>
-class SignalPack;
-
-template <typename D, typename E>
+template <typename E>
 class Events;
 
 using REACT_IMPL::ObserverAction;
@@ -39,7 +36,6 @@ using REACT_IMPL::WeightHint;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Observer
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
 class Observer
 {
 private:
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 7f211392..ac5c6030 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -29,83 +29,34 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename S>
 class Signal;
 
-template <typename D, typename S>
+template <typename S>
 class VarSignal;
 
-template <typename D, typename S, typename TOp>
-class TempSignal;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalPack - Wraps several nodes in a tuple. Create with comma operator.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename ... TValues
->
-class SignalPack
-{
-public:
-    SignalPack(const Signal<D,TValues>&  ... deps) :
-        Data( std::tie(deps ...) )
-    {}
-
-    template <typename ... TCurValues, typename TAppendValue>
-    SignalPack(const SignalPack<D, TCurValues ...>& curArgs, const Signal<D,TAppendValue>& newArg) :
-        Data( std::tuple_cat(curArgs.Data, std::tie(newArg)) )
-    {}
-
-    std::tuple<const Signal<D,TValues>& ...> Data;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// With - Utility function to create a SignalPack
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename ... TValues
->
-auto With(const Signal<D,TValues>&  ... deps)
-    -> SignalPack<D,TValues ...>
-{
-    return SignalPack<D,TValues...>(deps ...);
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// MakeVar
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename V,
     typename S = typename std::decay<V>::type,
-    class = typename std::enable_if<
-        ! IsSignal<S>::value>::type,
-    class = typename std::enable_if<
-        ! IsEvent<S>::value>::type
+    class = typename std::enable_if<!IsSignalType<S>::value>::type,
+    class = typename std::enable_if<!IsEventType<S>::value>::type
 >
-auto MakeVar(V&& value)
-    -> VarSignal<D,S>
+auto MakeVar(V&& value) -> VarSignal<S>
 {
-    return VarSignal<D,S>(
-        std::make_shared<REACT_IMPL::VarNode<D,S>>(
+    return VarSignal<S>(
+        std::make_shared<REACT_IMPL::VarNode<S>>(
             std::forward<V>(value)));
 }
 
-template
-<
-    typename D,
-    typename S
->
-auto MakeVar(std::reference_wrapper<S> value)
-    -> VarSignal<D,S&>
+template <typename S>
+auto MakeVar(std::reference_wrapper<S> value) -> VarSignal<S&>
 {
-    return VarSignal<D,S&>(
-        std::make_shared<REACT_IMPL::VarNode<D,std::reference_wrapper<S>>>(value));
+    return VarSignal<S&>(
+        std::make_shared<REACT_IMPL::VarNode<std::reference_wrapper<S>>>(value));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -113,15 +64,13 @@ auto MakeVar(std::reference_wrapper<S> value)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename V,
     typename S = typename std::decay<V>::type,
     typename TInner = typename S::ValueT,
-    class = typename std::enable_if<
-        IsSignal<S>::value>::type
+    class = typename std::enable_if<IsSignal<S>::value>::type
 >
 auto MakeVar(V&& value)
-    -> VarSignal<D,Signal<D,TInner>>
+    -> VarSignal<Signal<TInner>>
 {
     return VarSignal<D,Signal<D,TInner>>(
         std::make_shared<REACT_IMPL::VarNode<D,Signal<D,TInner>>>(
@@ -130,7 +79,7 @@ auto MakeVar(V&& value)
 
 template
 <
-    typename D,
+    
     typename V,
     typename S = typename std::decay<V>::type,
     typename TInner = typename S::ValueT,
@@ -151,7 +100,7 @@ auto MakeVar(V&& value)
 // Single arg
 template
 <
-    typename D,
+    
     typename TValue,
     typename FIn,
     typename F = typename std::decay<FIn>::type,
@@ -169,7 +118,7 @@ auto MakeSignal(const Signal<D,TValue>& arg, FIn&& func)
 // Multiple args
 template
 <
-    typename D,
+    
     typename ... TValues,
     typename FIn,
     typename F = typename std::decay<FIn>::type,
@@ -203,396 +152,10 @@ auto MakeSignal(const SignalPack<D,TValues...>& argPack, FIn&& func)
         argPack.Data);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Unary operators
-///////////////////////////////////////////////////////////////////////////////////////////////////
-#define REACT_DECLARE_OP(op,name)                                                   \
-template <typename T>                                                               \
-struct name ## OpFunctor                                                            \
-{                                                                                   \
-    T operator()(const T& v) const { return op v; }                                 \
-};                                                                                  \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename TSignal,                                                               \
-    typename D = typename TSignal::DomainT,                                         \
-    typename TVal = typename TSignal::ValueT,                                       \
-    class = typename std::enable_if<                                                \
-        IsSignal<TSignal>::value>::type,                                            \
-    typename F = name ## OpFunctor<TVal>,                                           \
-    typename S = typename std::result_of<F(TVal)>::type,                            \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,REACT_IMPL::SignalNodePtrT<D,TVal>>   \
->                                                                                   \
-auto operator op(const TSignal& arg)                                                \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F(), GetNodePtr(arg)));                                                 \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename D,                                                                     \
-    typename TVal,                                                                  \
-    typename TOpIn,                                                                 \
-    typename F = name ## OpFunctor<TVal>,                                           \
-    typename S = typename std::result_of<F(TVal)>::type,                            \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,TOpIn>                                \
->                                                                                   \
-auto operator op(TempSignal<D,TVal,TOpIn>&& arg)                                    \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F(), arg.StealOp()));                                                   \
-}
-
-REACT_DECLARE_OP(+, UnaryPlus)
-REACT_DECLARE_OP(-, UnaryMinus)
-REACT_DECLARE_OP(!, LogicalNegation)
-REACT_DECLARE_OP(~, BitwiseComplement)
-REACT_DECLARE_OP(++, Increment)
-REACT_DECLARE_OP(--, Decrement)
-
-#undef REACT_DECLARE_OP                                                                      
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Binary operators
-///////////////////////////////////////////////////////////////////////////////////////////////////
-#define REACT_DECLARE_OP(op,name)                                                   \
-template <typename L, typename R>                                                   \
-struct name ## OpFunctor                                                            \
-{                                                                                   \
-    auto operator()(const L& lhs, const R& rhs) const                               \
-        -> decltype(std::declval<L>() op std::declval<R>())                         \
-    {                                                                               \
-        return lhs op rhs;                                                          \
-    }                                                                               \
-};                                                                                  \
-                                                                                    \
-template <typename L, typename R>                                                   \
-struct name ## OpRFunctor                                                           \
-{                                                                                   \
-    name ## OpRFunctor(name ## OpRFunctor&& other) :                                \
-        LeftVal( std::move(other.LeftVal) )                                         \
-    {}                                                                              \
-                                                                                    \
-    template <typename T>                                                           \
-    name ## OpRFunctor(T&& val) :                                                   \
-        LeftVal( std::forward<T>(val) )                                             \
-    {}                                                                              \
-                                                                                    \
-    name ## OpRFunctor(const name ## OpRFunctor& other) = delete;                   \
-                                                                                    \
-    auto operator()(const R& rhs) const                                             \
-        -> decltype(std::declval<L>() op std::declval<R>())                         \
-    {                                                                               \
-        return LeftVal op rhs;                                                      \
-    }                                                                               \
-                                                                                    \
-    L LeftVal;                                                                      \
-};                                                                                  \
-                                                                                    \
-template <typename L, typename R>                                                   \
-struct name ## OpLFunctor                                                           \
-{                                                                                   \
-    name ## OpLFunctor(name ## OpLFunctor&& other) :                                \
-        RightVal( std::move(other.RightVal) )                                       \
-    {}                                                                              \
-                                                                                    \
-    template <typename T>                                                           \
-    name ## OpLFunctor(T&& val) :                                                   \
-        RightVal( std::forward<T>(val) )                                            \
-    {}                                                                              \
-                                                                                    \
-    name ## OpLFunctor(const name ## OpLFunctor& other) = delete;                   \
-                                                                                    \
-    auto operator()(const L& lhs) const                                             \
-        -> decltype(std::declval<L>() op std::declval<R>())                         \
-    {                                                                               \
-        return lhs op RightVal;                                                     \
-    }                                                                               \
-                                                                                    \
-    R RightVal;                                                                     \
-};                                                                                  \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename TLeftSignal,                                                           \
-    typename TRightSignal,                                                          \
-    typename D = typename TLeftSignal::DomainT,                                     \
-    typename TLeftVal = typename TLeftSignal::ValueT,                               \
-    typename TRightVal = typename TRightSignal::ValueT,                             \
-    class = typename std::enable_if<                                                \
-        IsSignal<TLeftSignal>::value>::type,                                        \
-    class = typename std::enable_if<                                                \
-        IsSignal<TRightSignal>::value>::type,                                       \
-    typename F = name ## OpFunctor<TLeftVal,TRightVal>,                             \
-    typename S = typename std::result_of<F(TLeftVal,TRightVal)>::type,              \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,                                      \
-        REACT_IMPL::SignalNodePtrT<D,TLeftVal>,                                     \
-        REACT_IMPL::SignalNodePtrT<D,TRightVal>>                                    \
->                                                                                   \
-auto operator op(const TLeftSignal& lhs, const TRightSignal& rhs)                   \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F(), GetNodePtr(lhs), GetNodePtr(rhs)));                                \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename TLeftSignal,                                                           \
-    typename TRightValIn,                                                           \
-    typename D = typename TLeftSignal::DomainT,                                     \
-    typename TLeftVal = typename TLeftSignal::ValueT,                               \
-    typename TRightVal = typename std::decay<TRightValIn>::type,                    \
-    class = typename std::enable_if<                                                \
-        IsSignal<TLeftSignal>::value>::type,                                        \
-    class = typename std::enable_if<                                                \
-        ! IsSignal<TRightVal>::value>::type,                                        \
-    typename F = name ## OpLFunctor<TLeftVal,TRightVal>,                            \
-    typename S = typename std::result_of<F(TLeftVal)>::type,                        \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,                                      \
-        REACT_IMPL::SignalNodePtrT<D,TLeftVal>>                                     \
->                                                                                   \
-auto operator op(const TLeftSignal& lhs, TRightValIn&& rhs)                         \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F( std::forward<TRightValIn>(rhs) ), GetNodePtr(lhs)));                 \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename TLeftValIn,                                                            \
-    typename TRightSignal,                                                          \
-    typename D = typename TRightSignal::DomainT,                                    \
-    typename TLeftVal = typename std::decay<TLeftValIn>::type,                      \
-    typename TRightVal = typename TRightSignal::ValueT,                             \
-    class = typename std::enable_if<                                                \
-        ! IsSignal<TLeftVal>::value>::type,                                         \
-    class = typename std::enable_if<                                                \
-        IsSignal<TRightSignal>::value>::type,                                       \
-    typename F = name ## OpRFunctor<TLeftVal,TRightVal>,                            \
-    typename S = typename std::result_of<F(TRightVal)>::type,                       \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,                                      \
-        REACT_IMPL::SignalNodePtrT<D,TRightVal>>                                    \
->                                                                                   \
-auto operator op(TLeftValIn&& lhs, const TRightSignal& rhs)                         \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F( std::forward<TLeftValIn>(lhs) ), GetNodePtr(rhs)));                  \
-}                                                                                   \
-template                                                                            \
-<                                                                                   \
-    typename D,                                                                     \
-    typename TLeftVal,                                                              \
-    typename TLeftOp,                                                               \
-    typename TRightVal,                                                             \
-    typename TRightOp,                                                              \
-    typename F = name ## OpFunctor<TLeftVal,TRightVal>,                             \
-    typename S = typename std::result_of<F(TLeftVal,TRightVal)>::type,              \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,TLeftOp,TRightOp>                     \
->                                                                                   \
-auto operator op(TempSignal<D,TLeftVal,TLeftOp>&& lhs,                              \
-                 TempSignal<D,TRightVal,TRightOp>&& rhs)                            \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F(), lhs.StealOp(), rhs.StealOp()));                                    \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename D,                                                                     \
-    typename TLeftVal,                                                              \
-    typename TLeftOp,                                                               \
-    typename TRightSignal,                                                          \
-    typename TRightVal = typename TRightSignal::ValueT,                             \
-    class = typename std::enable_if<                                                \
-        IsSignal<TRightSignal>::value>::type,                                       \
-    typename F = name ## OpFunctor<TLeftVal,TRightVal>,                             \
-    typename S = typename std::result_of<F(TLeftVal,TRightVal)>::type,              \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,                                      \
-        TLeftOp,                                                                    \
-        REACT_IMPL::SignalNodePtrT<D,TRightVal>>                                    \
->                                                                                   \
-auto operator op(TempSignal<D,TLeftVal,TLeftOp>&& lhs,                              \
-                 const TRightSignal& rhs)                                           \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F(), lhs.StealOp(), GetNodePtr(rhs)));                                  \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename TLeftSignal,                                                           \
-    typename D,                                                                     \
-    typename TRightVal,                                                             \
-    typename TRightOp,                                                              \
-    typename TLeftVal = typename TLeftSignal::ValueT,                               \
-    class = typename std::enable_if<                                                \
-        IsSignal<TLeftSignal>::value>::type,                                        \
-    typename F = name ## OpFunctor<TLeftVal,TRightVal>,                             \
-    typename S = typename std::result_of<F(TLeftVal,TRightVal)>::type,              \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,                                      \
-        REACT_IMPL::SignalNodePtrT<D,TLeftVal>,                                     \
-        TRightOp>                                                                   \
->                                                                                   \
-auto operator op(const TLeftSignal& lhs, TempSignal<D,TRightVal,TRightOp>&& rhs)    \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F(), GetNodePtr(lhs), rhs.StealOp()));                                  \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename D,                                                                     \
-    typename TLeftVal,                                                              \
-    typename TLeftOp,                                                               \
-    typename TRightValIn,                                                           \
-    typename TRightVal = typename std::decay<TRightValIn>::type,                    \
-    class = typename std::enable_if<                                                \
-        ! IsSignal<TRightVal>::value>::type,                                        \
-    typename F = name ## OpLFunctor<TLeftVal,TRightVal>,                            \
-    typename S = typename std::result_of<F(TLeftVal)>::type,                        \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,TLeftOp>                              \
->                                                                                   \
-auto operator op(TempSignal<D,TLeftVal,TLeftOp>&& lhs, TRightValIn&& rhs)           \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F( std::forward<TRightValIn>(rhs) ), lhs.StealOp()));                   \
-}                                                                                   \
-                                                                                    \
-template                                                                            \
-<                                                                                   \
-    typename TLeftValIn,                                                            \
-    typename D,                                                                     \
-    typename TRightVal,                                                             \
-    typename TRightOp,                                                              \
-    typename TLeftVal = typename std::decay<TLeftValIn>::type,                      \
-    class = typename std::enable_if<                                                \
-        ! IsSignal<TLeftVal>::value>::type,                                         \
-    typename F = name ## OpRFunctor<TLeftVal,TRightVal>,                            \
-    typename S = typename std::result_of<F(TRightVal)>::type,                       \
-    typename TOp = REACT_IMPL::FunctionOp<S,F,TRightOp>                             \
->                                                                                   \
-auto operator op(TLeftValIn&& lhs, TempSignal<D,TRightVal,TRightOp>&& rhs)          \
-    -> TempSignal<D,S,TOp>                                                          \
-{                                                                                   \
-    return TempSignal<D,S,TOp>(                                                     \
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(                        \
-            F( std::forward<TLeftValIn>(lhs) ), rhs.StealOp()));                    \
-}                                                                                   
-
-REACT_DECLARE_OP(+, Addition)
-REACT_DECLARE_OP(-, Subtraction)
-REACT_DECLARE_OP(*, Multiplication)
-REACT_DECLARE_OP(/, Division)
-REACT_DECLARE_OP(%, Modulo)
-
-REACT_DECLARE_OP(==, Equal)
-REACT_DECLARE_OP(!=, NotEqual)
-REACT_DECLARE_OP(<, Less)
-REACT_DECLARE_OP(<=, LessEqual)
-REACT_DECLARE_OP(>, Greater)
-REACT_DECLARE_OP(>=, GreaterEqual)
-
-REACT_DECLARE_OP(&&, LogicalAnd)
-REACT_DECLARE_OP(||, LogicalOr)
-
-REACT_DECLARE_OP(&, BitwiseAnd)
-REACT_DECLARE_OP(|, BitwiseOr)
-REACT_DECLARE_OP(^, BitwiseXor)
-//REACT_DECLARE_OP(<<, BitwiseLeftShift); // MSVC: Internal compiler error
-//REACT_DECLARE_OP(>>, BitwiseRightShift);
-
-#undef REACT_DECLARE_OP 
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Comma operator overload to create signal pack from 2 signals.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TLeftVal,
-    typename TRightVal
->
-auto operator,(const Signal<D,TLeftVal>& a, const Signal<D,TRightVal>& b)
-    -> SignalPack<D,TLeftVal, TRightVal>
-{
-    return SignalPack<D, TLeftVal, TRightVal>(a, b);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Comma operator overload to append node to existing signal pack.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename ... TCurValues,
-    typename TAppendValue
->
-auto operator,(const SignalPack<D, TCurValues ...>& cur, const Signal<D,TAppendValue>& append)
-    -> SignalPack<D,TCurValues ... , TAppendValue>
-{
-    return SignalPack<D, TCurValues ... , TAppendValue>(cur, append);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// operator->* overload to connect signals to a function and return the resulting signal.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Single arg
-template
-<
-    typename D,
-    typename F,
-    template <typename D_, typename V_> class TSignal,
-    typename TValue,
-    class = typename std::enable_if<
-        IsSignal<TSignal<D,TValue>>::value>::type
->
-auto operator->*(const TSignal<D,TValue>& arg, F&& func)
-    -> Signal<D, typename std::result_of<F(TValue)>::type>
-{
-    return REACT::MakeSignal(arg, std::forward<F>(func));
-}
-
-// Multiple args
-template
-<
-    typename D,
-    typename F,
-    typename ... TValues
->
-auto operator->*(const SignalPack<D,TValues ...>& argPack, F&& func)
-    -> Signal<D, typename std::result_of<F(TValues ...)>::type>
-{
-    return REACT::MakeSignal(argPack, std::forward<F>(func));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TInnerValue
->
+template <typename TInnerValue>
 auto Flatten(const Signal<D,Signal<D,TInnerValue>>& outer)
     -> Signal<D,TInnerValue>
 {
@@ -604,11 +167,7 @@ auto Flatten(const Signal<D,Signal<D,TInnerValue>>& outer)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
+template <typename S>
 class Signal : public REACT_IMPL::SignalBase<D,S>
 {
 private:
@@ -670,78 +229,14 @@ class Signal : public REACT_IMPL::SignalBase<D,S>
     }
 };
 
-// Specialize for references
-template
-<
-    typename D,
-    typename S
->
-class Signal<D,S&> : public REACT_IMPL::SignalBase<D,std::reference_wrapper<S>>
-{
-private:
-    using NodeT     = REACT_IMPL::SignalNode<D,std::reference_wrapper<S>>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
-
-public:
-    using ValueT = S;
-
-    // Default ctor
-    Signal() = default;
-
-    // Copy ctor
-    Signal(const Signal&) = default;
-
-    // Move ctor
-    Signal(Signal&& other) :
-        Signal::SignalBase( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit Signal(NodePtrT&& nodePtr) :
-        Signal::SignalBase( std::move(nodePtr) )
-    {}
-
-    // Copy assignment
-    Signal& operator=(const Signal&) = default;
-
-    // Move assignment
-    Signal& operator=(Signal&& other)
-    {
-        Signal::SignalBase::operator=( std::move(other) );
-        return *this;
-    }
-
-    const S& Value() const      { return Signal::SignalBase::getValue(); }
-    const S& operator()() const { return Signal::SignalBase::getValue(); }
-
-    bool Equals(const Signal& other) const
-    {
-        return Signal::SignalBase::Equals(other);
-    }
-
-    bool IsValid() const
-    {
-        return Signal::SignalBase::IsValid();
-    }
-
-    void SetWeightHint(WeightHint weight)
-    {
-        Signal::SignalBase::SetWeightHint(weight);
-    }
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarSignal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
-class VarSignal : public Signal<D,S>
+template <typename S>
+class VarSignal : public Signal<S>
 {
 private:
-    using NodeT     = REACT_IMPL::VarNode<D,S>;
+    using NodeT     = REACT_IMPL::VarNode<S>;
     using NodePtrT  = std::shared_ptr<NodeT>;
 
 public:
@@ -800,113 +295,12 @@ class VarSignal : public Signal<D,S>
     }
 };
 
-// Specialize for references
-template
-<
-    typename D,
-    typename S
->
-class VarSignal<D,S&> : public Signal<D,std::reference_wrapper<S>>
-{
-private:
-    using NodeT     = REACT_IMPL::VarNode<D,std::reference_wrapper<S>>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
-
-public:
-    using ValueT = S;
-
-    // Default ctor
-    VarSignal() = default;
-
-    // Copy ctor
-    VarSignal(const VarSignal&) = default;
-
-    // Move ctor
-    VarSignal(VarSignal&& other) :
-        VarSignal::Signal( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit VarSignal(NodePtrT&& nodePtr) :
-        VarSignal::Signal( std::move(nodePtr) )
-    {}
-
-    // Copy assignment
-    VarSignal& operator=(const VarSignal&) = default;
-
-    // Move assignment
-    VarSignal& operator=(VarSignal&& other)
-    {
-        VarSignal::Signal::operator=( std::move(other) );
-        return *this;
-    }
-
-    void Set(std::reference_wrapper<S> newValue) const
-    {
-        VarSignal::SignalBase::setValue(newValue);
-    }
-
-    const VarSignal& operator<<=(std::reference_wrapper<S> newValue) const
-    {
-        VarSignal::SignalBase::setValue(newValue);
-        return *this;
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TempSignal
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename TOp
->
-class TempSignal : public Signal<D,S>
-{
-private:
-    using NodeT     = REACT_IMPL::SignalOpNode<D,S,TOp>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
-
-public:
-    // Default ctor
-    TempSignal() = default;
-
-    // Copy ctor
-    TempSignal(const TempSignal&) = default;
-
-    // Move ctor
-    TempSignal(TempSignal&& other) :
-        TempSignal::Signal( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit TempSignal(NodePtrT&& ptr) :
-        TempSignal::Signal( std::move(ptr) )
-    {}
-
-    // Copy assignment
-    TempSignal& operator=(const TempSignal&) = default;
-
-    // Move assignemnt
-    TempSignal& operator=(TempSignal&& other)
-    {
-        TempSignal::Signal::operator=( std::move(other) );
-        return *this;
-    }
-
-    TOp StealOp()
-    {
-        return std::move(reinterpret_cast<NodeT*>(this->ptr_.get())->StealOp());
-    }
-};
-
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-template <typename D, typename L, typename R>
-bool Equals(const Signal<D,L>& lhs, const Signal<D,R>& rhs)
+template <typename L, typename R>
+bool Equals(const Signal<L>& lhs, const Signal<R>& rhs)
 {
     return lhs.Equals(rhs);
 }
diff --git a/include/react/TypeTraits.h b/include/react/TypeTraits.h
index c6b6b7dd..bd0ac99c 100644
--- a/include/react/TypeTraits.h
+++ b/include/react/TypeTraits.h
@@ -16,47 +16,35 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename S>
 class Signal;
 
-template <typename D, typename S>
+template <typename S>
 class VarSignal;
 
-template <typename D, typename S, typename TOp>
-class TempSignal;
-
-template <typename D, typename E>
+template <typename E>
 class Events;
 
-template <typename D, typename E>
+template <typename E>
 class EventSource;
 
-template <typename D, typename E, typename TOp>
-class TempEvents;
-
 template <typename D>
 class Observer;
 
-template <typename D>
-class ScopedObserver;
-
-template <typename TSourceDomain, typename TTargetDomain>
-class Continuation;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsSignal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
 struct IsSignal { static const bool value = false; };
 
-template <typename D, typename T>
-struct IsSignal<Signal<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsSignal<Signal<T>> { static const bool value = true; };
 
-template <typename D, typename T>
-struct IsSignal<VarSignal<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsSignal<VarSignal<T>> { static const bool value = true; };
 
-template <typename D, typename T, typename TOp>
-struct IsSignal<TempSignal<D,T,TOp>> { static const bool value = true; };
+template <typename T>
+constexpr bool IsSignalType = IsSignal<T>::value;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsEvent
@@ -64,14 +52,11 @@ struct IsSignal<TempSignal<D,T,TOp>> { static const bool value = true; };
 template <typename T>
 struct IsEvent { static const bool value = false; };
 
-template <typename D, typename T>
-struct IsEvent<Events<D,T>> { static const bool value = true; };
-
-template <typename D, typename T>
-struct IsEvent<EventSource<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsEvent<Events<T>> { static const bool value = true; };
 
-template <typename D, typename T, typename TOp>
-struct IsEvent<TempEvents<D,T,TOp>> { static const bool value = true; };
+template <typename T>
+struct IsEvent<EventSource<T>> { static const bool value = true; };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsObserver
@@ -82,41 +67,23 @@ struct IsObserver { static const bool value = false; };
 template <typename D>
 struct IsObserver<Observer<D>> { static const bool value = true; };
 
-template <typename D>
-struct IsObserver<ScopedObserver<D>> { static const bool value = true; };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsContinuation
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsContinuation { static const bool value = false; };
-
-template <typename D, typename D2>
-struct IsContinuation<Continuation<D,D2>> { static const bool value = true; };
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsObservable
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
 struct IsObservable { static const bool value = false; };
 
-template <typename D, typename T>
-struct IsObservable<Signal<D,T>> { static const bool value = true; };
-
-template <typename D, typename T>
-struct IsObservable<VarSignal<D,T>> { static const bool value = true; };
-
-template <typename D, typename T, typename TOp>
-struct IsObservable<TempSignal<D,T,TOp>> { static const bool value = true; };
+template <typename T>
+struct IsObservable<Signal<T>> { static const bool value = true; };
 
-template <typename D, typename T>
-struct IsObservable<Events<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsObservable<VarSignal<T>> { static const bool value = true; };
 
-template <typename D, typename T>
-struct IsObservable<EventSource<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsObservable<Events<T>> { static const bool value = true; };
 
-template <typename D, typename T, typename TOp>
-struct IsObservable<TempEvents<D,T,TOp>> { static const bool value = true; };
+template <typename T>
+struct IsObservable<EventSource<T>> { static const bool value = true; };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsReactive
@@ -124,44 +91,32 @@ struct IsObservable<TempEvents<D,T,TOp>> { static const bool value = true; };
 template <typename T>
 struct IsReactive { static const bool value = false; };
 
-template <typename D, typename T>
-struct IsReactive<Signal<D,T>> { static const bool value = true; };
-
-template <typename D, typename T>
-struct IsReactive<VarSignal<D,T>> { static const bool value = true; };
-
-template <typename D, typename T, typename TOp>
-struct IsReactive<TempSignal<D,T,TOp>> { static const bool value = true; };
+template <typename T>
+struct IsReactive<Signal<T>> { static const bool value = true; };
 
-template <typename D, typename T>
-struct IsReactive<Events<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsReactive<VarSignal<T>> { static const bool value = true; };
 
-template <typename D, typename T>
-struct IsReactive<EventSource<D,T>> { static const bool value = true; };
+template <typename T>
+struct IsReactive<Events<T>> { static const bool value = true; };
 
-template <typename D, typename T, typename TOp>
-struct IsReactive<TempEvents<D,T,TOp>> { static const bool value = true; };
+template <typename T>
+struct IsReactive<EventSource<T>> { static const bool value = true; };
 
 template <typename D>
 struct IsReactive<Observer<D>> { static const bool value = true; };
 
-template <typename D>
-struct IsReactive<ScopedObserver<D>> { static const bool value = true; };
-
-template <typename D, typename D2>
-struct IsReactive<Continuation<D,D2>> { static const bool value = true; };
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// DecayInput
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
 struct DecayInput { using Type = T; };
 
-template <typename D, typename T>
-struct DecayInput<VarSignal<D,T>> { using Type = Signal<D,T>; };
+template <typename T>
+struct DecayInput<VarSignal<T>> { using Type = Signal<T>; };
 
-template <typename D, typename T>
-struct DecayInput<EventSource<D,T>> { using Type = Events<D,T>; };
+template <typename T>
+struct DecayInput<EventSource<T>> { using Type = Events<T>; };
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index eb438a0c..64cccaee 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -21,18 +21,14 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename L, typename R>
+template <typename L, typename R>
 bool Equals(const L& lhs, const R& rhs);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
-class SignalNode : public ObservableNode<D>
+template <typename S>
+class SignalNode : public ObservableNode
 {
 public:
     SignalNode() = default;
@@ -52,19 +48,15 @@ class SignalNode : public ObservableNode<D>
     S value_;
 };
 
-template <typename D, typename S>
-using SignalNodePtrT = std::shared_ptr<SignalNode<D,S>>;
+template <typename S>
+using SignalNodePtrT = std::shared_ptr<SignalNode<S>>;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
+template <typename S>
 class VarNode :
-    public SignalNode<D,S>,
+    public SignalNode<S>,
     public IInputNode
 {
     using Engine = typename VarNode::Engine;
@@ -228,12 +220,10 @@ class FunctionOp : public ReactiveOpBase<TDeps...>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename S,
     typename TOp
 >
-class SignalOpNode :
-    public SignalNode<D,S>
+class SignalOpNode : public SignalNode<S>
 {
     using Engine = typename SignalOpNode::Engine;
 
@@ -261,8 +251,7 @@ class SignalOpNode :
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
+        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(GetObjectId(*this), turn.Id()));
         
         bool changed = false;
 
@@ -279,8 +268,7 @@ class SignalOpNode :
             }
         }// ~timer
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(GetObjectId(*this), turn.Id()));
 
         if (changed)
             Engine::OnNodePulse(*this, turn);
@@ -309,11 +297,10 @@ class SignalOpNode :
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
     typename TOuter,
     typename TInner
 >
-class FlattenNode : public SignalNode<D,TInner>
+class FlattenNode : public SignalNode<TInner>
 {
     using Engine = typename FlattenNode::Engine;
 
@@ -377,8 +364,8 @@ class FlattenNode : public SignalNode<D,TInner>
     virtual int         DependencyCount() const override    { return 2; }
 
 private:
-    std::shared_ptr<SignalNode<D,TOuter>>   outer_;
-    std::shared_ptr<SignalNode<D,TInner>>   inner_;
+    std::shared_ptr<SignalNode<TOuter>>   outer_;
+    std::shared_ptr<SignalNode<TInner>>   inner_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/

From f9ca5bbb1915619da1ba2594cf60ce2fc1ccdcf5 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 25 Jul 2016 18:19:34 +0200
Subject: [PATCH 28/75] Refactor WIP.

---
 benchmarks/src/BenchmarkBase.h                |   2 +-
 benchmarks/src/BenchmarkFanout.h              |   2 +-
 benchmarks/src/BenchmarkGrid.h                |   2 +-
 benchmarks/src/BenchmarkLifeSim.h             |   2 +-
 benchmarks/src/BenchmarkRandom.h              |   2 +-
 benchmarks/src/BenchmarkSequence.h            |   2 +-
 benchmarks/src/Main.cpp                       |   2 +-
 examples/src/BasicAlgorithms.cpp              |   2 +-
 examples/src/BasicComposition.cpp             |   2 +-
 examples/src/BasicEvents.cpp                  |   2 +-
 examples/src/BasicObservers.cpp               |   2 +-
 examples/src/BasicReactors.cpp                |   2 +-
 examples/src/BasicSignals.cpp                 |   2 +-
 examples/src/BasicSynchronization.cpp         |   2 +-
 include/react/Algorithm.h                     |   2 +-
 include/react/Domain.h                        | 246 +-----------------
 include/react/Event.h                         |  99 +++----
 include/react/Observer.h                      |   2 +-
 include/react/Reactor.h                       |   2 +-
 include/react/Signal.h                        | 169 +++---------
 include/react/TypeTraits.h                    |  45 +---
 include/react/common/Concurrency.h            |   2 +-
 include/react/common/Containers.h             |   2 +-
 include/react/common/RefCounting.h            |   2 +-
 include/react/common/SourceIdSet.h            |   2 +-
 include/react/common/Timing.h                 |   2 +-
 include/react/common/TopoQueue.h              |   2 +-
 include/react/common/Types.h                  |   2 +-
 include/react/common/Util.h                   |   2 +-
 include/react/detail/Defs.h                   |   2 +-
 include/react/detail/DomainBase.h             |   2 +-
 include/react/detail/EngineBase.h             |   2 +-
 include/react/detail/EventBase.h              |  10 +-
 include/react/detail/IReactiveEngine.h        | 133 ++--------
 include/react/detail/IReactiveNode.h          |  20 +-
 include/react/detail/ObserverBase.h           |   2 +-
 include/react/detail/ReactiveBase.h           |   2 +-
 include/react/detail/ReactiveInput.h          |   2 +-
 include/react/detail/SignalBase.h             |   2 +-
 include/react/detail/graph/AlgorithmNodes.h   |  18 +-
 .../react/detail/graph/ContinuationNodes.h    |   8 +-
 include/react/detail/graph/EventNodes.h       | 131 +++++++---
 include/react/detail/graph/GraphBase.h        |   2 +-
 include/react/detail/graph/ObserverNodes.h    |   8 +-
 include/react/detail/graph/ReactorNodes.h     |   4 +-
 include/react/detail/graph/SignalNodes.h      |   8 +-
 include/react/engine/PulsecountEngine.h       |   2 +-
 include/react/engine/SubtreeEngine.h          |   2 +-
 include/react/engine/ToposortEngine.h         |   2 +-
 include/react/logging/EventLog.h              |   2 +-
 include/react/logging/EventRecords.h          |   2 +-
 include/react/logging/Logging.h               |   2 +-
 src/engine/PulsecountEngine.cpp               |   2 +-
 src/engine/SubtreeEngine.cpp                  |   2 +-
 src/engine/ToposortEngine.cpp                 |   2 +-
 src/logging/EventLog.cpp                      |   2 +-
 src/logging/EventRecords.cpp                  |   2 +-
 tests/src/EventStreamTest.cpp                 |   2 +-
 tests/src/EventStreamTest.h                   |   2 +-
 tests/src/EventStreamTestQ.cpp                |   2 +-
 tests/src/MoveTest.cpp                        |   2 +-
 tests/src/MoveTest.h                          |   2 +-
 tests/src/ObserverTest.cpp                    |   2 +-
 tests/src/ObserverTest.h                      |   2 +-
 tests/src/ObserverTestQ.cpp                   |   2 +-
 tests/src/OperationsTest.cpp                  |   2 +-
 tests/src/OperationsTest.h                    |   2 +-
 tests/src/OperationsTestQ.cpp                 |   2 +-
 tests/src/ParallelizationTest.cpp             |   2 +-
 tests/src/ParallelizationTest.h               |   2 +-
 tests/src/SignalTest.cpp                      |   2 +-
 tests/src/SignalTest.h                        |   2 +-
 tests/src/SignalTestQ.cpp                     |   2 +-
 tests/src/TestUtil.h                          |   2 +-
 tests/src/TransactionTest.cpp                 |   2 +-
 tests/src/TransactionTest.h                   |   2 +-
 76 files changed, 295 insertions(+), 730 deletions(-)

diff --git a/benchmarks/src/BenchmarkBase.h b/benchmarks/src/BenchmarkBase.h
index deaaf931..4b65306a 100644
--- a/benchmarks/src/BenchmarkBase.h
+++ b/benchmarks/src/BenchmarkBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkFanout.h b/benchmarks/src/BenchmarkFanout.h
index bc2c8b3e..6feaf567 100644
--- a/benchmarks/src/BenchmarkFanout.h
+++ b/benchmarks/src/BenchmarkFanout.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkGrid.h b/benchmarks/src/BenchmarkGrid.h
index 551f3db8..d719afaa 100644
--- a/benchmarks/src/BenchmarkGrid.h
+++ b/benchmarks/src/BenchmarkGrid.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkLifeSim.h b/benchmarks/src/BenchmarkLifeSim.h
index 1ebab386..39acc2df 100644
--- a/benchmarks/src/BenchmarkLifeSim.h
+++ b/benchmarks/src/BenchmarkLifeSim.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkRandom.h b/benchmarks/src/BenchmarkRandom.h
index 63cbd996..bf3ba9d1 100644
--- a/benchmarks/src/BenchmarkRandom.h
+++ b/benchmarks/src/BenchmarkRandom.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkSequence.h b/benchmarks/src/BenchmarkSequence.h
index f30d3064..5e96d3c7 100644
--- a/benchmarks/src/BenchmarkSequence.h
+++ b/benchmarks/src/BenchmarkSequence.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index 00284776..93a79d78 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index 69229ee5..dd20b7bc 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicComposition.cpp b/examples/src/BasicComposition.cpp
index da6075f5..d5354bae 100644
--- a/examples/src/BasicComposition.cpp
+++ b/examples/src/BasicComposition.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index 656a141b..0db396c3 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index ba5b3420..2c1b911e 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicReactors.cpp b/examples/src/BasicReactors.cpp
index 1e30cc1c..534c1346 100644
--- a/examples/src/BasicReactors.cpp
+++ b/examples/src/BasicReactors.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 03707949..a5a82445 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index ec2be1c9..4a7f6529 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index 7caed812..edfca68e 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/Domain.h b/include/react/Domain.h
index e27c2514..b1fae362 100644
--- a/include/react/Domain.h
+++ b/include/react/Domain.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -29,38 +29,22 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename T>
 class Signal;
 
-template <typename D, typename S>
+template <typename T>
 class VarSignal;
 
-template <typename D, typename S, typename TOp>
-class TempSignal;
-
-template <typename D, typename E>
+template <typename T>
 class Events;
 
-template <typename D, typename E>
+template <typename T>
 class EventSource;
 
-template <typename D, typename E, typename TOp>
-class TempEvents;
-
 enum class Token;
 
-template <typename D>
 class Observer;
 
-template <typename D>
-class ScopedObserver;
-
-template <typename D>
-class Reactor;
-
-template <typename D, typename ... TValues>
-class SignalPack;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Common types & constants
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -102,14 +86,14 @@ class TransactionStatus
     {}
 
     // Move ctor
-    inline TransactionStatus(TransactionStatus&& other) :
+    TransactionStatus(TransactionStatus&& other) :
         statePtr_( std::move(other.statePtr_) )
     {
         other.statePtr_ = StateT::Create();
     }
 
     // Move assignment
-    inline TransactionStatus& operator=(TransactionStatus&& other)
+    TransactionStatus& operator=(TransactionStatus&& other)
     {
         if (this != &other)
         {
@@ -139,222 +123,6 @@ class TransactionStatus
     friend void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& func);
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Continuation
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename D2 = D
->
-class Continuation : public REACT_IMPL::ContinuationBase<D,D2>
-{
-private:
-    using NodePtrT  = REACT_IMPL::NodeBasePtrT<D>;
-
-public:
-    using SourceDomainT = D;
-    using TargetDomainT = D2;
-
-    // Default ctor
-    Continuation() = default;
-
-    // Move ctor
-    Continuation(Continuation&& other) :
-        Continuation::ContinuationBase( std::move(other) )
-    {}
-
-    // Node ctor
-    explicit Continuation(NodePtrT&& nodePtr) :
-        Continuation::ContinuationBase( std::move(nodePtr) )
-    {}
-
-    // Move assignment
-    Continuation& operator=(Continuation&& other)
-    {
-        Continuation::ContinuationBase::operator=( std::move(other) );
-        return *this;
-    }
-
-    // Deleted copy ctor & assignment
-    Continuation(const Continuation&) = delete;
-    Continuation& operator=(const Continuation&) = delete;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeContinuation - Signals
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename DOut = D,
-    typename S,
-    typename FIn
->
-auto MakeContinuation(TransactionFlagsT flags, const Signal<D,S>& trigger, FIn&& func)
-    -> Continuation<D,DOut>
-{
-    static_assert(DOut::is_concurrent,
-        "MakeContinuation: Target domain does not support concurrent input.");
-
-    using REACT_IMPL::SignalContinuationNode;
-    using F = typename std::decay<FIn>::type;
-
-    return Continuation<D,DOut>(
-        std::make_shared<SignalContinuationNode<D,DOut,S,F>>(
-            flags, GetNodePtr(trigger), std::forward<FIn>(func)));
-}
-
-template
-<
-    typename D,
-    typename DOut = D,
-    typename S,
-    typename FIn
->
-auto MakeContinuation(const Signal<D,S>& trigger, FIn&& func)
-    -> Continuation<D,DOut>
-{
-    return MakeContinuation<D,DOut>(0, trigger, std::forward<FIn>(func));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeContinuation - Events
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename DOut = D,
-    typename E,
-    typename FIn
->
-auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&& func)
-    -> Continuation<D,DOut>
-{
-    static_assert(DOut::is_concurrent,
-        "MakeContinuation: Target domain does not support concurrent input.");
-
-    using REACT_IMPL::EventContinuationNode;
-    using REACT_IMPL::AddContinuationRangeWrapper;
-    using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::EventRange;
-
-    using F = typename std::decay<FIn>::type;
-
-    using WrapperT =
-        typename std::conditional<
-            IsCallableWith<F,void, EventRange<E>>::value,
-            F,
-            typename std::conditional<
-                IsCallableWith<F, void, E>::value,
-                AddContinuationRangeWrapper<E, F>,
-                void
-            >::type
-        >::type;
-
-    static_assert(! std::is_same<WrapperT,void>::value,
-        "MakeContinuation: Passed function does not match any of the supported signatures.");
-
-    return Continuation<D,DOut>(
-        std::make_shared<EventContinuationNode<D,DOut,E,WrapperT>>(
-            flags, GetNodePtr(trigger), std::forward<FIn>(func)));
-}
-
-template
-<
-    typename D,
-    typename DOut = D,
-    typename E,
-    typename FIn
->
-auto MakeContinuation(const Events<D,E>& trigger, FIn&& func)
-    -> Continuation<D,DOut>
-{
-    return MakeContinuation<D,DOut>(0, trigger, std::forward<FIn>(func));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeContinuation - Synced
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename DOut = D,
-    typename E,
-    typename FIn,
-    typename ... TDepValues
->
-auto MakeContinuation(TransactionFlagsT flags, const Events<D,E>& trigger,
-                      const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Continuation<D,DOut>
-{
-    static_assert(DOut::is_concurrent,
-        "MakeContinuation: Target domain does not support concurrent input.");
-
-    using REACT_IMPL::SyncedContinuationNode;
-    using REACT_IMPL::AddContinuationRangeWrapper;
-    using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::EventRange;
-
-    using F = typename std::decay<FIn>::type;
-
-    using WrapperT =
-        typename std::conditional<
-            IsCallableWith<F, void, EventRange<E>, TDepValues ...>::value,
-            F,
-            typename std::conditional<
-                IsCallableWith<F, void, E, TDepValues ...>::value,
-                AddContinuationRangeWrapper<E, F, TDepValues ...>,
-                void
-            >::type
-        >::type;
-
-    static_assert(! std::is_same<WrapperT,void>::value,
-        "MakeContinuation: Passed function does not match any of the supported signatures.");
-
-    struct NodeBuilder_
-    {
-        NodeBuilder_(TransactionFlagsT flags, const Events<D,E>& trigger, FIn&& func) :
-            MyFlags( flags ),
-            MyTrigger( trigger ),
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Continuation<D,DOut>
-        {
-            return Continuation<D,DOut>(
-                std::make_shared<SyncedContinuationNode<D,DOut,E,WrapperT,TDepValues...>>(
-                    MyFlags,
-                    GetNodePtr(MyTrigger),
-                    std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
-        }
-
-        TransactionFlagsT   MyFlags;
-        const Events<D,E>&  MyTrigger;
-        FIn                 MyFunc;
-    };
-
-    return REACT_IMPL::apply(
-        NodeBuilder_( flags, trigger, std::forward<FIn>(func) ),
-        depPack.Data);
-}
-
-template
-<
-    typename D,
-    typename DOut = D,
-    typename E,
-    typename FIn,
-    typename ... TDepValues
->
-auto MakeContinuation(const Events<D,E>& trigger,
-                      const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Continuation<D,DOut>
-{
-    return MakeContinuation<D,DOut>(0, trigger, depPack, std::forward<FIn>(func));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// DoTransaction
 ///////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Event.h b/include/react/Event.h
index 8ca754c2..599c2ad6 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -25,30 +25,19 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class Events;
+template <typename T>
+class EventStream;
 
-template <typename E>
+template <typename T>
 class EventSource;
 
 enum class Token;
 
-template <typename S>
+template <typename T>
 class Signal;
 
 using REACT_IMPL::WeightHint;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeEventSource
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E = Token>
-auto MakeEventSource() -> EventSource<E>
-{
-    using REACT_IMPL::EventSourceNode;
-
-    return EventSource<E>(std::make_shared<EventSourceNode<E>>());
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -284,24 +273,24 @@ struct Tokenizer
     Token operator()(const T&) const { return Token::value; }
 };
 
-template <typename TEvents>
-auto Tokenize(TEvents&& source) -> decltype(Transform(source, Tokenizer{}))
+template <typename T>
+auto Tokenize(T&& source) -> decltype(auto)
 {
-    return Transform(source, Tokenizer{});
+    return Transform(source, Tokenizer{ });
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Events
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E = Token>
-class Events : public REACT_IMPL::EventStreamBase<E>
+template <typename T = Token>
+class Events : public REACT_IMPL::EventStreamBase<T>
 {
 private:
-    using NodeT     = REACT_IMPL::EventStreamNode<E>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
+    using NodeType     = REACT_IMPL::EventStreamNode<T>;
+    using NodePtrType  = std::shared_ptr<NodeType>;
 
 public:
-    using ValueT = E;
+    using ValueType = T;
 
     // Default ctor
     Events() = default;
@@ -310,24 +299,16 @@ class Events : public REACT_IMPL::EventStreamBase<E>
     Events(const Events&) = default;
 
     // Move ctor
-    Events(Events&& other) :
-        Events::EventStreamBase( std::move(other) )
-    {}
+    Events(Events&& other) = default;
 
     // Node ctor
-    explicit Events(NodePtrT&& nodePtr) :
-        Events::EventStreamBase( std::move(nodePtr) )
-    {}
+    explicit Events(NodePtrT&& nodePtr) = default;
 
     // Copy assignment
     Events& operator=(const Events&) = default;
 
     // Move assignment
-    Events& operator=(Events&& other)
-    {
-        Events::EventStreamBase::operator=( std::move(other) );
-        return *this;
-    }
+    Events& operator=(Events&& other) = default;
 
     bool Equals(const Events& other) const
     {
@@ -344,43 +325,47 @@ class Events : public REACT_IMPL::EventStreamBase<E>
         Events::EventStreamBase::SetWeightHint(weight);
     }
 
-    auto Tokenize() const
-        -> decltype(REACT::Tokenize(std::declval<Events>()))
+    auto Tokenize() const -> decltype(auto)
     {
         return REACT::Tokenize(*this);
     }
 
     template <typename ... TArgs>
-    auto Merge(TArgs&& ... args) const
-        -> decltype(REACT::Merge(std::declval<Events>(), std::forward<TArgs>(args) ...))
+    auto Merge(TArgs&& ... args) const -> decltype(auto)
     {
         return REACT::Merge(*this, std::forward<TArgs>(args) ...);
     }
 
     template <typename F>
-    auto Filter(F&& f) const
-        -> decltype(REACT::Filter(std::declval<Events>(), std::forward<F>(f)))
+    auto Filter(F&& f) const -> decltype(auto)
     {
         return REACT::Filter(*this, std::forward<F>(f));
     }
 
     template <typename F>
-    auto Transform(F&& f) const
-        -> decltype(REACT::Transform(std::declval<Events>(), std::forward<F>(f)))
+    auto Transform(F&& f) const -> decltype(auto)
     {
         return REACT::Transform(*this, std::forward<F>(f));
     }
+
+    template <typename E = Token>
+    static auto Create() -> EventSource<E>
+    {
+        using REACT_IMPL::EventSourceNode;
+
+        return EventSource<E>(std::make_shared<EventSourceNode<E>>());
+    }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSource
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E = Token>
-class EventSource : public Events<E>
+template <typename T = Token>
+class EventSource : public Events<T>
 {
 private:
-    using NodeT     = REACT_IMPL::EventSourceNode<D,E>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
+    using NodeType     = REACT_IMPL::EventSourceNode<T>;
+    using NodePtrType  = std::shared_ptr<NodeType>;
 
 public:
     // Default ctor
@@ -390,9 +375,7 @@ class EventSource : public Events<E>
     EventSource(const EventSource&) = default;
 
     // Move ctor
-    EventSource(EventSource&& other) :
-        EventSource::Events( std::move(other) )
-    {}
+    EventSource(EventSource&& other) = default;
 
     // Node ctor
     explicit EventSource(NodePtrT&& nodePtr) :
@@ -403,15 +386,11 @@ class EventSource : public Events<E>
     EventSource& operator=(const EventSource&) = default;
 
     // Move assignment
-    EventSource& operator=(EventSource&& other)
-    {
-        EventSource::Events::operator=( std::move(other) );
-        return *this;
-    }
+    EventSource& operator=(EventSource&& other) = default;
 
     // Explicit emit
-    void Emit(const E& e) const     { EventSource::EventStreamBase::emit(e); }
-    void Emit(E&& e) const          { EventSource::EventStreamBase::emit(std::move(e)); }
+    void Emit(const T& e) const     { EventSource::EventStreamBase::emit(e); }
+    void Emit(T&& e) const          { EventSource::EventStreamBase::emit(std::move(e)); }
 
     void Emit() const
     {
@@ -425,18 +404,18 @@ class EventSource : public Events<E>
 
     void operator()() const
     {
-        static_assert(std::is_same<E,Token>::value, "Can't emit on non token stream.");
+        static_assert(std::is_same<T,Token>::value, "Can't emit on non token stream.");
         EventSource::EventStreamBase::emit(Token::value);
     }
 
     // Stream style
-    const EventSource& operator<<(const E& e) const
+    const EventSource& operator<<(const T& e) const
     {
         EventSource::EventStreamBase::emit(e);
         return *this;
     }
 
-    const EventSource& operator<<(E&& e) const
+    const EventSource& operator<<(T&& e) const
     {
         EventSource::EventStreamBase::emit(std::move(e));
         return *this;
diff --git a/include/react/Observer.h b/include/react/Observer.h
index c9d986dc..17e72ebf 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/Reactor.h b/include/react/Reactor.h
index 2149dcac..92d3b006 100644
--- a/include/react/Reactor.h
+++ b/include/react/Reactor.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/Signal.h b/include/react/Signal.h
index ac5c6030..4bf28460 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -29,129 +29,12 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
+template <typename T>
 class Signal;
 
-template <typename S>
+template <typename T>
 class VarSignal;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeVar
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename V,
-    typename S = typename std::decay<V>::type,
-    class = typename std::enable_if<!IsSignalType<S>::value>::type,
-    class = typename std::enable_if<!IsEventType<S>::value>::type
->
-auto MakeVar(V&& value) -> VarSignal<S>
-{
-    return VarSignal<S>(
-        std::make_shared<REACT_IMPL::VarNode<S>>(
-            std::forward<V>(value)));
-}
-
-template <typename S>
-auto MakeVar(std::reference_wrapper<S> value) -> VarSignal<S&>
-{
-    return VarSignal<S&>(
-        std::make_shared<REACT_IMPL::VarNode<std::reference_wrapper<S>>>(value));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeVar (higher order reactives)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename V,
-    typename S = typename std::decay<V>::type,
-    typename TInner = typename S::ValueT,
-    class = typename std::enable_if<IsSignal<S>::value>::type
->
-auto MakeVar(V&& value)
-    -> VarSignal<Signal<TInner>>
-{
-    return VarSignal<D,Signal<D,TInner>>(
-        std::make_shared<REACT_IMPL::VarNode<D,Signal<D,TInner>>>(
-            std::forward<V>(value)));
-}
-
-template
-<
-    
-    typename V,
-    typename S = typename std::decay<V>::type,
-    typename TInner = typename S::ValueT,
-    class = typename std::enable_if<
-        IsEvent<S>::value>::type
->
-auto MakeVar(V&& value)
-    -> VarSignal<D,Events<D,TInner>>
-{
-    return VarSignal<D,Events<D,TInner>>(
-        std::make_shared<REACT_IMPL::VarNode<D,Events<D,TInner>>>(
-            std::forward<V>(value)));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeSignal
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Single arg
-template
-<
-    
-    typename TValue,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type,
-    typename S = typename std::result_of<F(TValue)>::type,
-    typename TOp = REACT_IMPL::FunctionOp<S,F, REACT_IMPL::SignalNodePtrT<D,TValue>>
->
-auto MakeSignal(const Signal<D,TValue>& arg, FIn&& func)
-    -> TempSignal<D,S,TOp>
-{
-    return TempSignal<D,S,TOp>(
-        std::make_shared<REACT_IMPL::SignalOpNode<D,S,TOp>>(
-            std::forward<FIn>(func), GetNodePtr(arg)));
-}
-
-// Multiple args
-template
-<
-    
-    typename ... TValues,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type,
-    typename S = typename std::result_of<F(TValues...)>::type,
-    typename TOp = REACT_IMPL::FunctionOp<S,F, REACT_IMPL::SignalNodePtrT<D,TValues> ...>
->
-auto MakeSignal(const SignalPack<D,TValues...>& argPack, FIn&& func)
-    -> TempSignal<D,S,TOp>
-{
-    using REACT_IMPL::SignalOpNode;
-
-    struct NodeBuilder_
-    {
-        NodeBuilder_(FIn&& func) :
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TValues>& ... args)
-            -> TempSignal<D,S,TOp>
-        {
-            return TempSignal<D,S,TOp>(
-                std::make_shared<SignalOpNode<D,S,TOp>>(
-                    std::forward<FIn>(MyFunc), GetNodePtr(args) ...));
-        }
-
-        FIn     MyFunc;
-    };
-
-    return REACT_IMPL::apply(
-        NodeBuilder_( std::forward<FIn>(func) ),
-        argPack.Data);
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -167,15 +50,15 @@ auto Flatten(const Signal<D,Signal<D,TInnerValue>>& outer)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class Signal : public REACT_IMPL::SignalBase<D,S>
+template <typename T>
+class Signal : public REACT_IMPL::SignalBase<T>
 {
 private:
-    using NodeT     = REACT_IMPL::SignalNode<D,S>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
+    using NodeType     = REACT_IMPL::SignalNode<T>;
+    using NodePtrType  = std::shared_ptr<NodeType>;
 
 public:
-    using ValueT = S;
+    using ValueType = T;
 
     // Default ctor
     Signal() = default;
@@ -184,12 +67,10 @@ class Signal : public REACT_IMPL::SignalBase<D,S>
     Signal(const Signal&) = default;
 
     // Move ctor
-    Signal(Signal&& other) :
-        Signal::SignalBase( std::move(other) )
-    {}
+    Signal(Signal&& other) = default;
 
     // Node ctor
-    explicit Signal(NodePtrT&& nodePtr) :
+    explicit Signal(NodePtrType&& nodePtr) :
         Signal::SignalBase( std::move(nodePtr) )
     {}
 
@@ -197,13 +78,9 @@ class Signal : public REACT_IMPL::SignalBase<D,S>
     Signal& operator=(const Signal&) = default;
 
     // Move assignment
-    Signal& operator=(Signal&& other)
-    {
-        Signal::SignalBase::operator=( std::move(other) );
-        return *this;
-    }
+    Signal& operator=(Signal&& other) = default;
 
-    const S& Value() const      { return Signal::SignalBase::getValue(); }
+    const S& Get() const        { return Signal::SignalBase::getValue(); }
     const S& operator()() const { return Signal::SignalBase::getValue(); }
 
     bool Equals(const Signal& other) const
@@ -227,6 +104,19 @@ class Signal : public REACT_IMPL::SignalBase<D,S>
             "Flatten requires a Signal or Events value type.");
         return REACT::Flatten(*this);
     }
+
+    template
+    <
+        typename ... Ts,
+        typename FIn,
+        typename F = typename std::decay<FIn>::type
+    >
+    static auto Create(FIn&& func, const Signal<TS>& ... args) -> Signal<S>
+    {
+        return Signal<S>(
+            std::make_shared<REACT_IMPL::SignalFuncNode<S, F>>(
+                std::forward<FIn>(func), GetNodePtr(args) ...));
+    }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -293,6 +183,15 @@ class VarSignal : public Signal<S>
     {
         VarSignal::SignalBase::modifyValue(func);
     }
+
+    /// Create
+    template <typename V>
+    static auto Create(V&& value) -> VarSignal<S>
+    {
+        return VarSignal<S>(
+            std::make_shared<REACT_IMPL::VarSignalNode<S>>(
+                std::forward<V>(value)));
+    }
 };
 
 /******************************************/ REACT_END /******************************************/
diff --git a/include/react/TypeTraits.h b/include/react/TypeTraits.h
index bd0ac99c..97c12654 100644
--- a/include/react/TypeTraits.h
+++ b/include/react/TypeTraits.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -16,19 +16,18 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
+template <typename T>
 class Signal;
 
-template <typename S>
+template <typename T>
 class VarSignal;
 
-template <typename E>
+template <typename T>
 class Events;
 
-template <typename E>
+template <typename T>
 class EventSource;
 
-template <typename D>
 class Observer;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -43,9 +42,6 @@ struct IsSignal<Signal<T>> { static const bool value = true; };
 template <typename T>
 struct IsSignal<VarSignal<T>> { static const bool value = true; };
 
-template <typename T>
-constexpr bool IsSignalType = IsSignal<T>::value;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsEvent
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -58,33 +54,6 @@ struct IsEvent<Events<T>> { static const bool value = true; };
 template <typename T>
 struct IsEvent<EventSource<T>> { static const bool value = true; };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsObserver
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsObserver { static const bool value = false; };
-
-template <typename D>
-struct IsObserver<Observer<D>> { static const bool value = true; };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsObservable
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsObservable { static const bool value = false; };
-
-template <typename T>
-struct IsObservable<Signal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsObservable<VarSignal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsObservable<Events<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsObservable<EventSource<T>> { static const bool value = true; };
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsReactive
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -103,8 +72,8 @@ struct IsReactive<Events<T>> { static const bool value = true; };
 template <typename T>
 struct IsReactive<EventSource<T>> { static const bool value = true; };
 
-template <typename D>
-struct IsReactive<Observer<D>> { static const bool value = true; };
+template <>
+struct IsReactive<Observer> { static const bool value = true; };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// DecayInput
diff --git a/include/react/common/Concurrency.h b/include/react/common/Concurrency.h
index e27fd9ba..0a5c350c 100644
--- a/include/react/common/Concurrency.h
+++ b/include/react/common/Concurrency.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/Containers.h b/include/react/common/Containers.h
index 9b77de06..1839bd46 100644
--- a/include/react/common/Containers.h
+++ b/include/react/common/Containers.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/RefCounting.h b/include/react/common/RefCounting.h
index 3a84dbb4..f2cd518a 100644
--- a/include/react/common/RefCounting.h
+++ b/include/react/common/RefCounting.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/SourceIdSet.h b/include/react/common/SourceIdSet.h
index 1cf89210..b1a3eeb0 100644
--- a/include/react/common/SourceIdSet.h
+++ b/include/react/common/SourceIdSet.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/Timing.h b/include/react/common/Timing.h
index 3775661d..84c58006 100644
--- a/include/react/common/Timing.h
+++ b/include/react/common/Timing.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/TopoQueue.h b/include/react/common/TopoQueue.h
index 8084d419..b86885ff 100644
--- a/include/react/common/TopoQueue.h
+++ b/include/react/common/TopoQueue.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/Types.h b/include/react/common/Types.h
index 5d747eee..0545f858 100644
--- a/include/react/common/Types.h
+++ b/include/react/common/Types.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/Util.h b/include/react/common/Util.h
index 39741ed7..19fe74f4 100644
--- a/include/react/common/Util.h
+++ b/include/react/common/Util.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/Defs.h b/include/react/detail/Defs.h
index 477ad6b4..5dd2f91f 100644
--- a/include/react/detail/Defs.h
+++ b/include/react/detail/Defs.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/DomainBase.h b/include/react/detail/DomainBase.h
index 67c7e8ae..7327874b 100644
--- a/include/react/detail/DomainBase.h
+++ b/include/react/detail/DomainBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/EngineBase.h b/include/react/detail/EngineBase.h
index 7b9af9de..501c9c26 100644
--- a/include/react/detail/EngineBase.h
+++ b/include/react/detail/EngineBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/EventBase.h b/include/react/detail/EventBase.h
index 583651aa..bf518860 100644
--- a/include/react/detail/EventBase.h
+++ b/include/react/detail/EventBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -22,12 +22,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventStreamBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E
->
-class EventStreamBase : public CopyableReactive<EventStreamNode<D,E>>
+template <typename E>
+class EventStreamBase : public ReactiveBase<EventStreamNode<E>>
 {
 public:
     EventStreamBase() = default;
diff --git a/include/react/detail/IReactiveEngine.h b/include/react/detail/IReactiveEngine.h
index 9a422cb8..b4e0b83c 100644
--- a/include/react/detail/IReactiveEngine.h
+++ b/include/react/detail/IReactiveEngine.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -21,132 +21,29 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IReactiveEngine
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TNode,
-    typename TTurn
->
 struct IReactiveEngine
 {
-    using NodeT = TNode;
-    using TurnT = TTurn;
+    using NodeId = uint;
+    using TurnId = uint;
 
-    void OnTurnAdmissionStart(TurnT& turn)  {}
-    void OnTurnAdmissionEnd(TurnT& turn)    {}
+    void OnTurnAdmissionStart(TurnId& turn)  {}
+    void OnTurnAdmissionEnd(TurnId& turn)    {}
 
-    void OnInputChange(NodeT& node, TurnT& turn)    {}
+    void OnInputChange(NodeId& node, TurnId& turn)    {}
 
-    void Propagate(TurnT& turn)  {}
+    void Propagate(TurnId& turn)  {}
 
-    void OnNodeCreate(NodeT& node)  {}
-    void OnNodeDestroy(NodeT& node) {}
+    void OnNodeCreate(NodeId& node)  {}
+    void OnNodeDestroy(NodeId& node) {}
 
-    void OnNodeAttach(NodeT& node, NodeT& parent)   {}
-    void OnNodeDetach(NodeT& node, NodeT& parent)   {}
+    void OnNodeAttach(NodeId node, NodeId parent)   {}
+    void OnNodeDetach(NodeId node, NodeId parent)   {}
 
-    void OnNodePulse(NodeT& node, TurnT& turn)      {}
-    void OnNodeIdlePulse(NodeT& node, TurnT& turn)  {}
+    void OnNodePulse(NodeId& node, TurnId& turn)      {}
+    void OnNodeIdlePulse(NodeId& node, TurnId& turn)  {}
 
-    void OnDynamicNodeAttach(NodeT& node, NodeT& parent, TurnT& turn)    {}
-    void OnDynamicNodeDetach(NodeT& node, NodeT& parent, TurnT& turn)    {}
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EngineInterface - Static wrapper for IReactiveEngine
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TEngine
->
-struct EngineInterface
-{
-    using NodeT = typename TEngine::NodeT;
-    using TurnT = typename TEngine::TurnT;
-
-    static TEngine& Instance()
-    {
-        static TEngine engine;
-        return engine;
-    }
-
-    static void OnTurnAdmissionStart(TurnT& turn)
-    {
-        Instance().OnTurnAdmissionStart(turn);
-    }
-
-    static void OnTurnAdmissionEnd(TurnT& turn)
-    {
-        Instance().OnTurnAdmissionEnd(turn);
-    }
-
-    static void OnInputChange(NodeT& node, TurnT& turn)
-    {
-        REACT_LOG(D::Log().template Append<InputNodeAdmissionEvent>(
-            GetObjectId(node), turn.Id()));
-        Instance().OnInputChange(node, turn);
-    }
-
-    static void Propagate(TurnT& turn)
-    {
-        Instance().Propagate(turn);
-    }
-
-    static void OnNodeCreate(NodeT& node)
-    {
-        REACT_LOG(D::Log().template Append<NodeCreateEvent>(
-            GetObjectId(node), node.GetNodeType()));
-        Instance().OnNodeCreate(node);
-    }
-
-    static void OnNodeDestroy(NodeT& node)
-    {
-        REACT_LOG(D::Log().template Append<NodeDestroyEvent>(
-            GetObjectId(node)));
-        Instance().OnNodeDestroy(node);
-    }
-
-    static void OnNodeAttach(NodeT& node, NodeT& parent)
-    {
-        REACT_LOG(D::Log().template Append<NodeAttachEvent>(
-            GetObjectId(node), GetObjectId(parent)));
-        Instance().OnNodeAttach(node, parent);
-    }
-
-    static void OnNodeDetach(NodeT& node, NodeT& parent)
-    {
-        REACT_LOG(D::Log().template Append<NodeDetachEvent>(
-            GetObjectId(node), GetObjectId(parent)));
-        Instance().OnNodeDetach(node, parent);
-    }
-
-    static void OnNodePulse(NodeT& node, TurnT& turn)
-    {
-        REACT_LOG(D::Log().template Append<NodePulseEvent>(
-            GetObjectId(node), turn.Id()));
-        Instance().OnNodePulse(node, turn);
-    }
-
-    static void OnNodeIdlePulse(NodeT& node, TurnT& turn)
-    {
-        REACT_LOG(D::Log().template Append<NodeIdlePulseEvent>(
-            GetObjectId(node), turn.Id()));
-        Instance().OnNodeIdlePulse(node, turn);
-    }
-
-    static void OnDynamicNodeAttach(NodeT& node, NodeT& parent, TurnT& turn)
-    {
-        REACT_LOG(D::Log().template Append<DynamicNodeAttachEvent>(
-            GetObjectId(node), GetObjectId(parent), turn.Id()));
-        Instance().OnDynamicNodeAttach(node, parent, turn);
-    }
-
-    static void OnDynamicNodeDetach(NodeT& node, NodeT& parent, TurnT& turn)
-    {
-        REACT_LOG(D::Log().template Append<DynamicNodeDetachEvent>(
-            GetObjectId(node), GetObjectId(parent), turn.Id()));
-        Instance().OnDynamicNodeDetach(node, parent, turn);
-    }
+    void OnDynamicNodeAttach(NodeId& node, NodeId& parent, TurnId& turn)    {}
+    void OnDynamicNodeDetach(NodeId& node, NodeId& parent, TurnId& turn)    {}
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/IReactiveNode.h b/include/react/detail/IReactiveNode.h
index b4d2e79c..34967834 100644
--- a/include/react/detail/IReactiveNode.h
+++ b/include/react/detail/IReactiveNode.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -13,6 +13,12 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
+enum class EUpdateResult
+{
+    UNCHANGED,
+    CHANGED
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IReactiveNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -25,24 +31,24 @@ struct IReactiveNode
 
     // Note: Could get rid of this ugly ptr by adding a template parameter to the interface
     // But that would mean all engine nodes need that template parameter too - so rather cast
-    virtual void    Tick(void* turnPtr) = 0;  
+    virtual EUpdateResult Update() = 0;  
 
     /// Input nodes can be manipulated externally.
-    virtual bool    IsInputNode() const = 0;
+    virtual bool IsInputNode() const = 0;
 
     /// Output nodes can't have any successors.
-    virtual bool    IsOutputNode() const = 0;
+    virtual bool IsOutputNode() const = 0;
 
     /// Dynamic nodes may change in topology as a result of tick.
-    virtual bool    IsDynamicNode() const = 0;
+    virtual bool IsDynamicNode() const = 0;
 
     // Number of predecessors.
     // This information is statically available at compile time on the graph layer,
     // so the engine does not have to calculate it again.
-    virtual int     DependencyCount() const = 0;
+    virtual int DependencyCount() const = 0;
 
     // Heavyweight nodes are worth parallelizing.
-    virtual bool    IsHeavyweight() const = 0;
+    virtual bool IsHeavyweight() const = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/ObserverBase.h b/include/react/detail/ObserverBase.h
index 814e0207..73f637fd 100644
--- a/include/react/detail/ObserverBase.h
+++ b/include/react/detail/ObserverBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/ReactiveBase.h b/include/react/detail/ReactiveBase.h
index d7f32124..12dafd82 100644
--- a/include/react/detail/ReactiveBase.h
+++ b/include/react/detail/ReactiveBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/ReactiveInput.h b/include/react/detail/ReactiveInput.h
index 3589d8c7..ffcbcd6b 100644
--- a/include/react/detail/ReactiveInput.h
+++ b/include/react/detail/ReactiveInput.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/SignalBase.h b/include/react/detail/SignalBase.h
index 6c41b9df..9b497136 100644
--- a/include/react/detail/SignalBase.h
+++ b/include/react/detail/SignalBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 454fdfbb..eb158c4b 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -110,7 +110,7 @@ class IterateNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -183,7 +183,7 @@ class IterateByRefNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -257,7 +257,7 @@ class SyncedIterateNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -351,7 +351,7 @@ class SyncedIterateByRefNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -429,7 +429,7 @@ class HoldNode : public SignalNode<D,S>
 
     virtual const char* GetNodeType() const override    { return "HoldNode"; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -497,7 +497,7 @@ class SnapshotNode : public SignalNode<D,S>
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -564,7 +564,7 @@ class MonitorNode : public EventStreamNode<D,E>
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -624,7 +624,7 @@ class PulseNode : public EventStreamNode<D,S>
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         typedef typename D::Engine::TurnT TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
diff --git a/include/react/detail/graph/ContinuationNodes.h b/include/react/detail/graph/ContinuationNodes.h
index c841d23f..6d494453 100644
--- a/include/react/detail/graph/ContinuationNodes.h
+++ b/include/react/detail/graph/ContinuationNodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -111,7 +111,7 @@ class SignalContinuationNode : public ContinuationNode<D>
     virtual const char* GetNodeType() const override        { return "SignalContinuationNode"; }
     virtual int         DependencyCount() const override    { return 1; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
 #ifdef REACT_ENABLE_LOGGING
         using TurnT = typename D::Engine::TurnT;
@@ -183,7 +183,7 @@ class EventContinuationNode : public ContinuationNode<D>
     virtual const char* GetNodeType() const override        { return "EventContinuationNode"; }
     virtual int         DependencyCount() const override    { return 1; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
 #ifdef REACT_ENABLE_LOGGING
         using TurnT = typename D::Engine::TurnT;
@@ -293,7 +293,7 @@ class SyncedContinuationNode : public ContinuationNode<D>
     virtual const char* GetNodeType() const override        { return "SyncedContinuationNode"; }
     virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 850b36c2..f6c750cc 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -27,7 +27,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename T>
 class SignalNode;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -47,19 +47,11 @@ struct BufferClearAccessPolicy :
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventStreamNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E
->
-class EventStreamNode :
-    public ObservableNode<D>,
-    private BufferClearAccessPolicy<D>
+template <typename T>
+class EventStreamNode : public ObservableNode
 {
 public:
-    using DataT     = std::vector<E>;
-    using EngineT   = typename D::Engine;
-    using TurnT     = typename EngineT::TurnT;
+    using StorageType = std::vector<T>;
 
     EventStreamNode() = default;
 
@@ -75,10 +67,14 @@ class EventStreamNode :
         });
     }
 
-    DataT&  Events() { return events_; }
+    StorageType&  Events()
+        { return events_; }
+
+    const StorageType&  Events() const
+        { return events_; }
 
 protected:
-    DataT   events_;
+    StorageType   events_;
 
 private:
     uint    curTurnId_  { (std::numeric_limits<uint>::max)() };
@@ -90,17 +86,11 @@ using EventStreamNodePtrT = std::shared_ptr<EventStreamNode<D,E>>;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSourceNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E
->
+template <typename E>
 class EventSourceNode :
-    public EventStreamNode<D,E>,
+    public EventStreamNode<E>,
     public IInputNode
 {
-    using Engine = typename EventSourceNode::Engine;
-
 public:
     EventSourceNode() :
         EventSourceNode::EventStreamNode{ }
@@ -117,7 +107,7 @@ class EventSourceNode :
     virtual bool        IsInputNode() const override        { return true; }
     virtual int         DependencyCount() const override    { return 0; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         REACT_ASSERT(false, "Ticked EventSourceNode\n");
     }
@@ -157,25 +147,86 @@ class EventSourceNode :
     bool changedFlag_ = false;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventOpNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template
+<
+    typename T,
+    typename ... Ds
+>
+class EventMergeNode : public EventStreamNode<T>
+{
+public:
+    template <typename ... Us>
+    EventMergeNode(Us&& ... args) :
+        EventOpNode::EventStreamNode( ),
+        op_( std::forward<TArgs>(args) ... )
+    {
+        Engine::OnNodeCreate(*this);
+        op_.template Attach<D>(*this);
+    }
+
+    ~EventOpNode()
+    {
+        if (!wasOpStolen_)
+            op_.template Detach<D>(*this);
+        Engine::OnNodeDestroy(*this);
+    }
+
+    virtual EUpdateResult Update() override
+    {
+        using TurnT = typename D::Engine::TurnT;
+        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+
+        this->SetCurrentTurn(turn, true);
+
+        {// timer
+            size_t count = 0;
+            using TimerT = typename EventOpNode::ScopedUpdateTimer;
+            TimerT scopedTimer( *this, count );
+
+            op_.Collect(turn, EventCollector( this->events_ ));
+
+            // Note: Count was passed by reference, so we can still change before the dtor
+            // of the scoped timer is called
+            count = this->events_.size();
+        }// ~timer
+
+        if (! this->events_.empty())
+            return EUpdateResult::CHANGED;
+        else
+            return EUpdateResult::UNCHANGED;
+    }
+
+    virtual const char* GetNodeType() const override
+        { return "EventOpNode"; }
+
+    virtual int DependencyCount() const override
+        { return TOp::dependency_count; }
+
+private:
+    TOp     op_;
+    bool    wasOpStolen_ = false;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventMergeOp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename E,
-    typename ... TDeps
+    typename T,
+    typename ... Ds
 >
-class EventMergeOp : public ReactiveOpBase<TDeps...>
+class EventMergeOp : public ReactiveOpBase<Ds...>
 {
 public:
-    template <typename ... TDepsIn>
-    EventMergeOp(TDepsIn&& ... deps) :
-        EventMergeOp::ReactiveOpBase(DontMove(), std::forward<TDepsIn>(deps) ...)
+    template <typename ... Us>
+    EventMergeOp(Us&& ... deps) :
+        EventMergeOp::ReactiveOpBase(DontMove(), std::forward<Us>(deps) ...)
     {}
 
-    EventMergeOp(EventMergeOp&& other) :
-        EventMergeOp::ReactiveOpBase( std::move(other) )
-    {}
+    EventMergeOp(EventMergeOp&& other) = default;
 
     template <typename TTurn, typename TCollector>
     void Collect(const TTurn& turn, const TCollector& collector) const
@@ -406,7 +457,7 @@ class EventOpNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -500,7 +551,7 @@ class EventFlattenNode : public EventStreamNode<D,TInner>
     virtual bool        IsDynamicNode() const override      { return true; }
     virtual int         DependencyCount() const override    { return 2; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         typedef typename D::Engine::TurnT TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -588,7 +639,7 @@ class SyncedEventTransformNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -679,7 +730,7 @@ class SyncedEventFilterNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -766,7 +817,7 @@ class EventProcessingNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -846,7 +897,7 @@ class SyncedEventProcessingNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -932,7 +983,7 @@ class EventJoinNode :
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
 
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index b7d79d27..66993500 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index 351a54e5..b597e828 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -118,7 +118,7 @@ class SignalObserverNode :
     virtual const char* GetNodeType() const override        { return "SignalObserverNode"; }
     virtual int         DependencyCount() const override    { return 1; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
 #ifdef REACT_ENABLE_LOGGING
         using TurnT = typename D::Engine::TurnT;
@@ -200,7 +200,7 @@ class EventObserverNode :
     virtual const char* GetNodeType() const override        { return "EventObserverNode"; }
     virtual int         DependencyCount() const override    { return 1; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
 #ifdef REACT_ENABLE_LOGGING
         using TurnT = typename D::Engine::TurnT;
@@ -288,7 +288,7 @@ class SyncedObserverNode :
     virtual const char* GetNodeType() const override        { return "SyncedObserverNode"; }
     virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
diff --git a/include/react/detail/graph/ReactorNodes.h b/include/react/detail/graph/ReactorNodes.h
index b693a5f0..c85cdcc0 100644
--- a/include/react/detail/graph/ReactorNodes.h
+++ b/include/react/detail/graph/ReactorNodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -88,7 +88,7 @@ class ReactorNode :
     virtual bool IsDynamicNode() const override { return true; }
     virtual bool IsOutputNode() const override  { return true; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         turnPtr_ = reinterpret_cast<TurnT*>(turnPtr);
 
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 64cccaee..9ea74832 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -79,7 +79,7 @@ class VarNode :
     virtual bool        IsInputNode() const override        { return true; }
     virtual int         DependencyCount() const override    { return 0; }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         REACT_ASSERT(false, "Ticked VarNode\n");
     }
@@ -246,7 +246,7 @@ class SignalOpNode : public SignalNode<S>
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
@@ -323,7 +323,7 @@ class FlattenNode : public SignalNode<TInner>
         Engine::OnNodeDestroy(*this);
     }
 
-    virtual void Tick(void* turnPtr) override
+    virtual void Update(void* turnPtr) override
     {
         using TurnT = typename D::Engine::TurnT;
         TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
diff --git a/include/react/engine/PulsecountEngine.h b/include/react/engine/PulsecountEngine.h
index ed813e54..95308f3c 100644
--- a/include/react/engine/PulsecountEngine.h
+++ b/include/react/engine/PulsecountEngine.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/engine/SubtreeEngine.h b/include/react/engine/SubtreeEngine.h
index 9a84d7cb..cfda49d1 100644
--- a/include/react/engine/SubtreeEngine.h
+++ b/include/react/engine/SubtreeEngine.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/engine/ToposortEngine.h b/include/react/engine/ToposortEngine.h
index 9f8f693c..331ecd11 100644
--- a/include/react/engine/ToposortEngine.h
+++ b/include/react/engine/ToposortEngine.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/logging/EventLog.h b/include/react/logging/EventLog.h
index e9622c7b..6b94277f 100644
--- a/include/react/logging/EventLog.h
+++ b/include/react/logging/EventLog.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/logging/EventRecords.h b/include/react/logging/EventRecords.h
index 4ec91cbe..ea2359f5 100644
--- a/include/react/logging/EventRecords.h
+++ b/include/react/logging/EventRecords.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/logging/Logging.h b/include/react/logging/Logging.h
index c5546883..3f0aacd2 100644
--- a/include/react/logging/Logging.h
+++ b/include/react/logging/Logging.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/src/engine/PulsecountEngine.cpp b/src/engine/PulsecountEngine.cpp
index 1e74bd1f..5fa3a844 100644
--- a/src/engine/PulsecountEngine.cpp
+++ b/src/engine/PulsecountEngine.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/src/engine/SubtreeEngine.cpp b/src/engine/SubtreeEngine.cpp
index 9189c697..c71d6e0f 100644
--- a/src/engine/SubtreeEngine.cpp
+++ b/src/engine/SubtreeEngine.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/src/engine/ToposortEngine.cpp b/src/engine/ToposortEngine.cpp
index 3d746452..54612191 100644
--- a/src/engine/ToposortEngine.cpp
+++ b/src/engine/ToposortEngine.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/src/logging/EventLog.cpp b/src/logging/EventLog.cpp
index a22601e5..dcd8f627 100644
--- a/src/logging/EventLog.cpp
+++ b/src/logging/EventLog.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/src/logging/EventRecords.cpp b/src/logging/EventRecords.cpp
index 84ced447..3145c43a 100644
--- a/src/logging/EventRecords.cpp
+++ b/src/logging/EventRecords.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/EventStreamTest.cpp b/tests/src/EventStreamTest.cpp
index 3714b371..6801c5e9 100644
--- a/tests/src/EventStreamTest.cpp
+++ b/tests/src/EventStreamTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/EventStreamTest.h b/tests/src/EventStreamTest.h
index bb2efce4..e33653a0 100644
--- a/tests/src/EventStreamTest.h
+++ b/tests/src/EventStreamTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/EventStreamTestQ.cpp b/tests/src/EventStreamTestQ.cpp
index 767a3dad..d61330d1 100644
--- a/tests/src/EventStreamTestQ.cpp
+++ b/tests/src/EventStreamTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/MoveTest.cpp b/tests/src/MoveTest.cpp
index 81f09f31..c5963745 100644
--- a/tests/src/MoveTest.cpp
+++ b/tests/src/MoveTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/MoveTest.h b/tests/src/MoveTest.h
index 46e1d39d..41eb5810 100644
--- a/tests/src/MoveTest.h
+++ b/tests/src/MoveTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ObserverTest.cpp b/tests/src/ObserverTest.cpp
index 87cb46eb..ae331812 100644
--- a/tests/src/ObserverTest.cpp
+++ b/tests/src/ObserverTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ObserverTest.h b/tests/src/ObserverTest.h
index cc07f44c..af5ac834 100644
--- a/tests/src/ObserverTest.h
+++ b/tests/src/ObserverTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ObserverTestQ.cpp b/tests/src/ObserverTestQ.cpp
index 68449272..1e36c088 100644
--- a/tests/src/ObserverTestQ.cpp
+++ b/tests/src/ObserverTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/OperationsTest.cpp b/tests/src/OperationsTest.cpp
index 72257431..cc3b576e 100644
--- a/tests/src/OperationsTest.cpp
+++ b/tests/src/OperationsTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/OperationsTest.h b/tests/src/OperationsTest.h
index 5ef9cc3d..1af27694 100644
--- a/tests/src/OperationsTest.h
+++ b/tests/src/OperationsTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/OperationsTestQ.cpp b/tests/src/OperationsTestQ.cpp
index 5da10bfa..83e8a7ab 100644
--- a/tests/src/OperationsTestQ.cpp
+++ b/tests/src/OperationsTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ParallelizationTest.cpp b/tests/src/ParallelizationTest.cpp
index aa583c17..9ef6d156 100644
--- a/tests/src/ParallelizationTest.cpp
+++ b/tests/src/ParallelizationTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ParallelizationTest.h b/tests/src/ParallelizationTest.h
index 6c5fd1d7..43a99f05 100644
--- a/tests/src/ParallelizationTest.h
+++ b/tests/src/ParallelizationTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/SignalTest.cpp b/tests/src/SignalTest.cpp
index d19239bd..44a68828 100644
--- a/tests/src/SignalTest.cpp
+++ b/tests/src/SignalTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/SignalTest.h b/tests/src/SignalTest.h
index 8d7a34e2..b20eabe8 100644
--- a/tests/src/SignalTest.h
+++ b/tests/src/SignalTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/SignalTestQ.cpp b/tests/src/SignalTestQ.cpp
index 6e93c730..b6bacde1 100644
--- a/tests/src/SignalTestQ.cpp
+++ b/tests/src/SignalTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/TestUtil.h b/tests/src/TestUtil.h
index dd00efb8..a6cc5306 100644
--- a/tests/src/TestUtil.h
+++ b/tests/src/TestUtil.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/TransactionTest.cpp b/tests/src/TransactionTest.cpp
index 61a51e11..487f7f5b 100644
--- a/tests/src/TransactionTest.cpp
+++ b/tests/src/TransactionTest.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/TransactionTest.h b/tests/src/TransactionTest.h
index 74fc7b6c..a332de90 100644
--- a/tests/src/TransactionTest.h
+++ b/tests/src/TransactionTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2014.
+//          Copyright Sebastian Jeckel 2016.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

From 46dee49a66e80f1909f5646b598200160205e6f3 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 28 Jul 2016 23:50:00 +0200
Subject: [PATCH 29/75] Refactoring WIP.

---
 include/react/Algorithm.h                     |  103 +-
 .../{IReactiveEngine.h => IReactiveGroup.h}   |   31 +-
 include/react/detail/IReactiveNode.h          |    9 +-
 include/react/detail/graph/EventNodes.h       | 1025 +++++------------
 include/react/detail/graph/GraphBase.h        |   74 +-
 include/react/detail/graph/SignalNodes.h      |    6 +-
 project/msvc/CppReact.vcxproj                 |    5 +-
 project/msvc/CppReact.vcxproj.filters         |   15 +-
 8 files changed, 408 insertions(+), 860 deletions(-)
 rename include/react/detail/{IReactiveEngine.h => IReactiveGroup.h} (68%)

diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index edfca68e..b6da68af 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -22,57 +22,43 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename T>
 class Signal;
 
-template <typename D, typename S>
+template <typename T>
 class VarSignal;
 
-template <typename D, typename E>
+template <typename T>
 class Events;
 
-template <typename D, typename E>
+template <typename T>
 class EventSource;
 
 enum class Token;
 
-template <typename D, typename ... TValues>
-class SignalPack;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Hold - Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename V,
-    typename T = typename std::decay<V>::type
->
-auto Hold(const Events<D,T>& events, V&& init)
-    -> Signal<D,T>
+template <typename T, typename V>
+auto Hold(const Events<T>& events, V&& init) -> Signal<T>
 {
     using REACT_IMPL::HoldNode;
 
-    return Signal<D,T>(
-        std::make_shared<HoldNode<D,T>>(
+    return Signal<T>(
+        std::make_shared<HoldNode<T>>(
             std::forward<V>(init), GetNodePtr(events)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Monitor - Emits value changes of target signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
-auto Monitor(const Signal<D,S>& target)
-    -> Events<D,S>
+template <typename T>
+auto Monitor(const Signal<T>& target) -> Events<T>
 {
     using REACT_IMPL::MonitorNode;
 
-    return Events<D,S>(
-        std::make_shared<MonitorNode<D, S>>(
+    return Events<T>(
+        std::make_shared<MonitorNode<T>>(
             GetNodePtr(target)));
 }
 
@@ -81,14 +67,13 @@ auto Monitor(const Signal<D,S>& target)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
+    typename S,
     typename E,
     typename V,
-    typename FIn,
-    typename S = typename std::decay<V>::type
+    typename F,
+    
 >
-auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
-    -> Signal<D,S>
+auto Iterate(const Events<E>& events, V&& init, F&& func) -> Signal<S>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
@@ -97,7 +82,7 @@ auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
     using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::EventRange;
 
-    using F = typename std::decay<FIn>::type;
+    using TFunc = typename std::decay<F>::type;
 
     using NodeT =
         typename std::conditional<
@@ -122,7 +107,7 @@ auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
         ! std::is_same<NodeT,void>::value,
         "Iterate: Passed function does not match any of the supported signatures.");
 
-    return Signal<D,S>(
+    return Signal<S>(
         std::make_shared<NodeT>(
             std::forward<V>(init), GetNodePtr(events), std::forward<FIn>(func)));
 }
@@ -132,16 +117,13 @@ auto Iterate(const Events<D,E>& events, V&& init, FIn&& func)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
+    typename S,
     typename E,
     typename V,
     typename FIn,
-    typename ... TDepValues,
-    typename S = typename std::decay<V>::type
+    typename ... TDepValues
 >
-auto Iterate(const Events<D,E>& events, V&& init,
-             const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Signal<D,S>
+auto Iterate(const Events<E>& events, V&& init, const SignalPack<TDepValues...>& depPack, FIn&& func) -> Signal<S>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
@@ -211,19 +193,13 @@ auto Iterate(const Events<D,E>& events, V&& init,
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E
->
-auto Snapshot(const Events<D,E>& trigger, const Signal<D,S>& target)
-    -> Signal<D,S>
+template <typename S, typename E>
+auto Snapshot(const Events<E>& trigger, const Signal<S>& target) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
 
-    return Signal<D,S>(
-        std::make_shared<SnapshotNode<D,S,E>>(
+    return Signal<S>(
+        std::make_shared<SnapshotNode<S,E>>(
             GetNodePtr(target), GetNodePtr(trigger)));
 }
 
@@ -232,32 +208,21 @@ auto Snapshot(const Events<D,E>& trigger, const Signal<D,S>& target)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Pulse - Emits value of target signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E
->
-auto Pulse(const Events<D,E>& trigger, const Signal<D,S>& target)
-    -> Events<D,S>
+template <typename S, typename E>
+auto Pulse(const Events<E>& trigger, const Signal<S>& target) -> Events<S>
 {
     using REACT_IMPL::PulseNode;
 
-    return Events<D,S>(
-        std::make_shared<PulseNode<D,S,E>>(
+    return Events<S>(
+        std::make_shared<PulseNode<S,E>>(
             GetNodePtr(target), GetNodePtr(trigger)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Changed - Emits token when target signal was changed
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
-auto Changed(const Signal<D,S>& target)
-    -> Events<D,Token>
+template <typename T>
+auto Changed(const Signal<T>& target) -> Events<Token>
 {
     return Monitor(target).Tokenize();
 }
@@ -267,12 +232,10 @@ auto Changed(const Signal<D,S>& target)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template
 <
-    typename D,
+    typename T,
     typename V,
-    typename S = typename std::decay<V>::type
 >
-auto ChangedTo(const Signal<D,S>& target, V&& value)
-    -> Events<D,Token>
+auto ChangedTo(const Signal<T>& target, V&& value) -> Events<Token>
 {
     return Monitor(target)
         .Filter([=] (const S& v) { return v == value; })
diff --git a/include/react/detail/IReactiveEngine.h b/include/react/detail/IReactiveGroup.h
similarity index 68%
rename from include/react/detail/IReactiveEngine.h
rename to include/react/detail/IReactiveGroup.h
index b4e0b83c..b86a389c 100644
--- a/include/react/detail/IReactiveEngine.h
+++ b/include/react/detail/IReactiveGroup.h
@@ -18,32 +18,31 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
+using NodeId = uint;
+using TurnId = uint;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IReactiveEngine
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IReactiveEngine
+struct IReactiveGroup
 {
-    using NodeId = uint;
-    using TurnId = uint;
-
-    void OnTurnAdmissionStart(TurnId& turn)  {}
-    void OnTurnAdmissionEnd(TurnId& turn)    {}
+    virtual ~IReactiveGroup() = 0;
 
-    void OnInputChange(NodeId& node, TurnId& turn)    {}
+    virtual void OnTurnAdmissionStart(TurnId turn) = 0;
+    virtual void OnTurnAdmissionEnd(TurnId turn) = 0;
 
-    void Propagate(TurnId& turn)  {}
+    virtual void OnInputChange(NodeId node, TurnId turn) = 0;
 
-    void OnNodeCreate(NodeId& node)  {}
-    void OnNodeDestroy(NodeId& node) {}
+    virtual void Propagate(TurnId turn) = 0;
 
-    void OnNodeAttach(NodeId node, NodeId parent)   {}
-    void OnNodeDetach(NodeId node, NodeId parent)   {}
+    virtual NodeId OnNodeCreate() = 0;
+    virtual void OnNodeDestroy(NodeId node) = 0;
 
-    void OnNodePulse(NodeId& node, TurnId& turn)      {}
-    void OnNodeIdlePulse(NodeId& node, TurnId& turn)  {}
+    virtual void OnNodeAttach(NodeId node, NodeId parent) = 0;
+    virtual void OnNodeDetach(NodeId node, NodeId parent) = 0;
 
-    void OnDynamicNodeAttach(NodeId& node, NodeId& parent, TurnId& turn)    {}
-    void OnDynamicNodeDetach(NodeId& node, NodeId& parent, TurnId& turn)    {}
+    virtual void OnDynamicNodeAttach(NodeId node, NodeId parent, TurnId turn) = 0;
+    virtual void OnDynamicNodeDetach(NodeId node, NodeId parent, TurnId turn) = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/IReactiveNode.h b/include/react/detail/IReactiveNode.h
index 34967834..68fe08be 100644
--- a/include/react/detail/IReactiveNode.h
+++ b/include/react/detail/IReactiveNode.h
@@ -13,10 +13,11 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-enum class EUpdateResult
+enum class UpdateResult
 {
-    UNCHANGED,
-    CHANGED
+    unchanged,
+    changed,
+    shifted
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -31,7 +32,7 @@ struct IReactiveNode
 
     // Note: Could get rid of this ugly ptr by adding a template parameter to the interface
     // But that would mean all engine nodes need that template parameter too - so rather cast
-    virtual EUpdateResult Update() = 0;  
+    virtual UpdateResult Update() = 0;  
 
     /// Input nodes can be manipulated externally.
     virtual bool IsInputNode() const = 0;
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index f6c750cc..00e35cbf 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -30,30 +30,23 @@
 template <typename T>
 class SignalNode;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// BufferClearAccessPolicy
-///
-/// Provides thread safe access to clear event buffer if parallel updating is enabled.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Note: Weird design due to empty base class optimization
-template <typename D>
-struct BufferClearAccessPolicy :
-    private ConditionalCriticalSection<tbb::spin_mutex, D::is_parallel>
-{
-    template <typename F>
-    void AccessBufferForClearing(const F& f) { this->Access(f); }
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventStreamNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class EventStreamNode : public ObservableNode
+class EventStreamNode : public NodeBase
 {
 public:
     using StorageType = std::vector<T>;
 
-    EventStreamNode() = default;
+    EventStreamNode(IReactiveGroup* group) : NodeBase( group )
+        { }
+
+    EventStreamNode(NodeBase&&) = default;
+    EventStreamNode& operator=(NodeBase&&) = default;
+
+    EventStreamNode(const NodeBase&) = delete;
+    EventStreamNode& operator=(const NodeBase&) = delete;
 
     void SetCurrentTurn(const TurnT& turn, bool forceUpdate = false, bool noClear = false)
     {
@@ -74,43 +67,36 @@ class EventStreamNode : public ObservableNode
         { return events_; }
 
 protected:
-    StorageType   events_;
+    StorageType events_;
 
 private:
-    uint    curTurnId_  { (std::numeric_limits<uint>::max)() };
+    uint curTurnId_ { (std::numeric_limits<uint>::max)() };
 };
 
-template <typename D, typename E>
-using EventStreamNodePtrT = std::shared_ptr<EventStreamNode<D,E>>;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSourceNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class EventSourceNode :
-    public EventStreamNode<E>,
-    public IInputNode
+template <typename T>
+class EventSourceNode : public EventStreamNode<T>, public IInputNode
 {
 public:
-    EventSourceNode() :
-        EventSourceNode::EventStreamNode{ }
-    {
-        Engine::OnNodeCreate(*this);
-    }
+    EventSourceNode(IReactiveGroup* group) : EventSourceNode::EventStreamNode( group )
+        { this->RegisterMe(); }
 
     ~EventSourceNode()
-    {
-        Engine::OnNodeDestroy(*this);
-    }
+        { this->UnregisterMe(); }
+
+    virtual const char* GetNodeType() const override
+        { return "EventSource"; }
 
-    virtual const char* GetNodeType() const override        { return "EventSourceNode"; }
-    virtual bool        IsInputNode() const override        { return true; }
-    virtual int         DependencyCount() const override    { return 0; }
+    virtual bool IsInputNode() const override
+        { return true; }
+
+    virtual int DependencyCount() const override
+        { return 0; }
 
     virtual void Update(void* turnPtr) override
-    {
-        REACT_ASSERT(false, "Ticked EventSourceNode\n");
-    }
+        { REACT_ASSERT(false, "Updated EventSourceNode\n"); }
 
     template <typename V>
     void AddInput(V&& v)
@@ -148,416 +134,189 @@ class EventSourceNode :
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventOpNode
+/// EventMergeNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename T,
-    typename ... Ds
->
-class EventMergeNode : public EventStreamNode<T>
+template <typename TOut, typename ... TIns>
+class EventMergeNode : public EventStreamNode<TOut>
 {
 public:
-    template <typename ... Us>
-    EventMergeNode(Us&& ... args) :
-        EventOpNode::EventStreamNode( ),
-        op_( std::forward<TArgs>(args) ... )
+    EventMergeNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIns>>& ... deps) :
+        EventMergeNode::EventStreamNode( group ),
+        depHolder_( deps ... )
     {
-        Engine::OnNodeCreate(*this);
-        op_.template Attach<D>(*this);
+        this->RegisterMe();
+        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
-    ~EventOpNode()
+    ~EventMergeNode()
     {
-        if (!wasOpStolen_)
-            op_.template Detach<D>(*this);
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(deps->GetNodeId())); }, depHolder_);
+        this->UnregisterMe();
     }
 
-    virtual EUpdateResult Update() override
+    virtual UpdateResult Update() override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        this->SetCurrentTurn(turn, true);
-
-        {// timer
-            size_t count = 0;
-            using TimerT = typename EventOpNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, count );
+        // this->SetCurrentTurn(turn, true);
 
-            op_.Collect(turn, EventCollector( this->events_ ));
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
-            // Note: Count was passed by reference, so we can still change before the dtor
-            // of the scoped timer is called
-            count = this->events_.size();
-        }// ~timer
-
-        if (! this->events_.empty())
-            return EUpdateResult::CHANGED;
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            return EUpdateResult::UNCHANGED;
+            return UpdateResult::unchanged;
     }
 
     virtual const char* GetNodeType() const override
-        { return "EventOpNode"; }
+        { return "EventMerge"; }
 
     virtual int DependencyCount() const override
-        { return TOp::dependency_count; }
+        { return sizeof...(Es); }
 
 private:
-    TOp     op_;
-    bool    wasOpStolen_ = false;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventMergeOp
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename T,
-    typename ... Ds
->
-class EventMergeOp : public ReactiveOpBase<Ds...>
-{
-public:
-    template <typename ... Us>
-    EventMergeOp(Us&& ... deps) :
-        EventMergeOp::ReactiveOpBase(DontMove(), std::forward<Us>(deps) ...)
-    {}
-
-    EventMergeOp(EventMergeOp&& other) = default;
-
-    template <typename TTurn, typename TCollector>
-    void Collect(const TTurn& turn, const TCollector& collector) const
+    template <typename U>
+    void MergeFromDep(const std::shared_ptr<EventStreamNode<U>& other)
     {
-        apply(CollectFunctor<TTurn, TCollector>( turn, collector ), this->deps_);
+        //arg->SetCurrentTurn(turn);
+        this->Events().insert(this->Events().end(), other->Events().begin(), other->Events().end());
     }
 
-    template <typename TTurn, typename TCollector, typename TFunctor>
-    void CollectRec(const TFunctor& functor) const
-    {
-        apply(reinterpret_cast<const CollectFunctor<TTurn,TCollector>&>(functor), this->deps_);
-    }
-
-private:
-    template <typename TTurn, typename TCollector>
-    struct CollectFunctor
-    {
-        CollectFunctor(const TTurn& turn, const TCollector& collector) :
-            MyTurn( turn ),
-            MyCollector( collector )
-        {}
-
-        void operator()(const TDeps& ... deps) const
-        {
-            REACT_EXPAND_PACK(collect(deps));
-        }
-
-        template <typename T>
-        void collect(const T& op) const
-        {
-            op.template CollectRec<TTurn,TCollector>(*this);
-        }
-
-        template <typename T>
-        void collect(const std::shared_ptr<T>& depPtr) const
-        {
-            depPtr->SetCurrentTurn(MyTurn);
-
-            for (const auto& v : depPtr->Events())
-                MyCollector(v);
-        }
-
-        const TTurn&        MyTurn;
-        const TCollector&   MyCollector;
-    };
+    std::tuple<std::shared_ptr<EventStreamNode<TIns> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventFilterOp
+/// EventTransformNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename E,
-    typename TFilter,
-    typename TDep
->
-class EventFilterOp : public ReactiveOpBase<TDep>
+template <typename TOut, typename TIn, typename F>
+class EventTransformNode : public EventStreamNode<TOut>
 {
 public:
-    template <typename TFilterIn, typename TDepIn>
-    EventFilterOp(TFilterIn&& filter, TDepIn&& dep) :
-        EventFilterOp::ReactiveOpBase{ DontMove(), std::forward<TDepIn>(dep) },
-        filter_( std::forward<TFilterIn>(filter) )
-    {}
-
-    EventFilterOp(EventFilterOp&& other) :
-        EventFilterOp::ReactiveOpBase{ std::move(other) },
-        filter_( std::move(other.filter_) )
-    {}
-
-    template <typename TTurn, typename TCollector>
-    void Collect(const TTurn& turn, const TCollector& collector) const
+    template <typename U>
+    EventTransformNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func) :
+        EventTransformNode::EventStreamNode( group ),
+        dep_( dep ),
+        func_( std::forward<U>(func) )
     {
-        collectImpl(turn, FilteredEventCollector<TCollector>{ filter_, collector }, getDep());
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
     }
 
-    template <typename TTurn, typename TCollector, typename TFunctor>
-    void CollectRec(const TFunctor& functor) const
+    ~EventTransformNode()
     {
-        // Can't recycle functor because MyFunc needs replacing
-        Collect<TTurn,TCollector>(functor.MyTurn, functor.MyCollector);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-private:
-    const TDep& getDep() const { return std::get<0>(this->deps_); }
-
-    template <typename TCollector>
-    struct FilteredEventCollector
-    {
-        FilteredEventCollector(const TFilter& filter, const TCollector& collector) :
-            MyFilter( filter ),
-            MyCollector( collector )
-        {}
-
-        void operator()(const E& e) const
-        {
-            // Accepted?
-            if (MyFilter(e))
-                MyCollector(e);
-        }
-
-        const TFilter&      MyFilter;
-        const TCollector&   MyCollector;    // The wrapped collector
-    };
-
-    template <typename TTurn, typename TCollector, typename T>
-    static void collectImpl(const TTurn& turn, const TCollector& collector, const T& op)
+    virtual UpdateResult Update() override
     {
-       op.Collect(turn, collector);
-    }
+        // this->SetCurrentTurn(turn, true);
 
-    template <typename TTurn, typename TCollector, typename T>
-    static void collectImpl(const TTurn& turn, const TCollector& collector,
-                            const std::shared_ptr<T>& depPtr)
-    {
-        depPtr->SetCurrentTurn(turn);
+        for (const auto& v : dep_->Events())
+            this->Events().push_back(func_(v));
 
-        for (const auto& v : depPtr->Events())
-            collector(v);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
+        else
+            return UpdateResult::unchanged;
     }
 
-    TFilter filter_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventTransformOp
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Todo: Refactor code duplication
-template
-<
-    typename E,
-    typename TFunc,
-    typename TDep
->
-class EventTransformOp : public ReactiveOpBase<TDep>
-{
-public:
-    template <typename TFuncIn, typename TDepIn>
-    EventTransformOp(TFuncIn&& func, TDepIn&& dep) :
-        EventTransformOp::ReactiveOpBase( DontMove(), std::forward<TDepIn>(dep) ),
-        func_( std::forward<TFuncIn>(func) )
-    {}
-
-    EventTransformOp(EventTransformOp&& other) :
-        EventTransformOp::ReactiveOpBase( std::move(other) ),
-        func_( std::move(other.func_) )
-    {}
-
-    template <typename TTurn, typename TCollector>
-    void Collect(const TTurn& turn, const TCollector& collector) const
-    {
-        collectImpl(turn, TransformEventCollector<TCollector>( func_, collector ), getDep());
-    }
+    virtual const char* GetNodeType() const override
+        { return "EventTransform"; }
 
-    template <typename TTurn, typename TCollector, typename TFunctor>
-    void CollectRec(const TFunctor& functor) const
-    {
-        // Can't recycle functor because MyFunc needs replacing
-        Collect<TTurn,TCollector>(functor.MyTurn, functor.MyCollector);
-    }
+    virtual int DependencyCount() const override
+        { return 1; }
 
 private:
-    const TDep& getDep() const { return std::get<0>(this->deps_); }
-
-    template <typename TTarget>
-    struct TransformEventCollector
-    {
-        TransformEventCollector(const TFunc& func, const TTarget& target) :
-            MyFunc( func ),
-            MyTarget( target )
-        {}
-
-        void operator()(const E& e) const
-        {
-            MyTarget(MyFunc(e));
-        }
+    std::shared_ptr<EventStreamNode<TIn> dep_;
 
-        const TFunc&    MyFunc;
-        const TTarget&  MyTarget;
-    };
-
-    template <typename TTurn, typename TCollector, typename T>
-    static void collectImpl(const TTurn& turn, const TCollector& collector, const T& op)
-    {
-       op.Collect(turn, collector);
-    }
-
-    template <typename TTurn, typename TCollector, typename T>
-    static void collectImpl(const TTurn& turn, const TCollector& collector, const std::shared_ptr<T>& depPtr)
-    {
-        depPtr->SetCurrentTurn(turn);
-
-        for (const auto& v : depPtr->Events())
-            collector(v);
-    }
-
-    TFunc func_;
+    F func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventOpNode
+/// EventFilterNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E,
-    typename TOp
->
-class EventOpNode :
-    public EventStreamNode<D,E>
+template <typename T, typename F>
+class EventFilterNode : public EventStreamNode<T>
 {
-    using Engine = typename EventOpNode::Engine;
-
 public:
-    template <typename ... TArgs>
-    EventOpNode(TArgs&& ... args) :
-        EventOpNode::EventStreamNode( ),
-        op_( std::forward<TArgs>(args) ... )
+    template <typename U>
+    EventFilterNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<T>>& dep, U&& pred) :
+        EventFilterNode::EventStreamNode( group ),
+        dep_( dep ),
+        pred_( std::forward<U>(pred) )
     {
-        Engine::OnNodeCreate(*this);
-        op_.template Attach<D>(*this);
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
     }
 
-    ~EventOpNode()
+    ~EventFilterNode()
     {
-        if (!wasOpStolen_)
-            op_.template Detach<D>(*this);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update() override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        this->SetCurrentTurn(turn, true);
+        // this->SetCurrentTurn(turn, true);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
+        for (const auto& v : dep_->Events())
+            if (pred_(v))
+                this->Events().push_back(v);
 
-        {// timer
-            size_t count = 0;
-            using TimerT = typename EventOpNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, count );
-
-            op_.Collect(turn, EventCollector( this->events_ ));
-
-            // Note: Count was passed by reference, so we can still change before the dtor
-            // of the scoped timer is called
-            count = this->events_.size();
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "EventOpNode"; }
-    virtual int         DependencyCount() const override    { return TOp::dependency_count; }
+    virtual const char* GetNodeType() const override
+        { return "EventFilter"; }
 
-    TOp StealOp()
-    {
-        REACT_ASSERT(wasOpStolen_ == false, "Op was already stolen.");
-        wasOpStolen_ = true;
-        op_.template Detach<D>(*this);
-        return std::move(op_);
-    }
+    virtual int DependencyCount() const override
+        { return 1; }
 
 private:
-    struct EventCollector
-    {
-        using DataT = typename EventOpNode::DataT;
-
-        EventCollector(DataT& events) : MyEvents( events )  {}
-
-        void operator()(const E& e) const { MyEvents.push_back(e); }
+    std::shared_ptr<EventStreamNode<T> dep_;
 
-        DataT& MyEvents;
-    };
-
-    TOp     op_;
-    bool    wasOpStolen_ = false;
+    F pred_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventFlattenNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TOuter,
-    typename TInner
->
-class EventFlattenNode : public EventStreamNode<D,TInner>
+template <typename TOuter, typename TInner>
+class EventFlattenNode : public EventStreamNode<TInner>
 {
-    using Engine = typename EventFlattenNode::Engine;
-
 public:
-    EventFlattenNode(const std::shared_ptr<SignalNode<D,TOuter>>& outer,
-                     const std::shared_ptr<EventStreamNode<D,TInner>>& inner) :
-        EventFlattenNode::EventStreamNode( ),
+    EventFlattenNode(IReactiveGroup* group, const std::shared_ptr<SignalNode<TOuter>>& outer, const std::shared_ptr<EventStreamNode<TInner>>& inner) :
+        EventFlattenNode::EventStreamNode( group ),
         outer_( outer ),
         inner_( inner )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *outer_);
-        Engine::OnNodeAttach(*this, *inner_);
+        this->RegisterMe();
+        this->AttachToMe(outer->GetNodeId());
+        this->AttachToMe(inner->GetNodeId());
     }
 
     ~EventFlattenNode()
     {
-        Engine::OnNodeDetach(*this, *outer_);
-        Engine::OnNodeDetach(*this, *inner_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(inner->GetNodeId());
+        this->DetachFromMe(outer->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override        { return "EventFlattenNode"; }
-    virtual bool        IsDynamicNode() const override      { return true; }
-    virtual int         DependencyCount() const override    { return 2; }
+    virtual const char* GetNodeType() const override
+        { return "EventFlatten"; }
 
-    virtual void Update(void* turnPtr) override
-    {
-        typedef typename D::Engine::TurnT TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+    virtual bool IsDynamicNode() const override
+        { return true; }
 
-        this->SetCurrentTurn(turn, true);
-        inner_->SetCurrentTurn(turn);
+    virtual int DependencyCount() const override
+        { return 2; }
+
+    virtual UpdateResult Update() override
+    {
+        // this->SetCurrentTurn(turn, true);
+        // inner_->SetCurrentTurn(turn);
 
         auto newInner = GetNodePtr(outer_->ValueRef());
 
@@ -569,285 +328,180 @@ class EventFlattenNode : public EventStreamNode<D,TInner>
             auto oldInner = inner_;
             inner_ = newInner;
 
-            Engine::OnDynamicNodeDetach(*this, *oldInner, turn);
-            Engine::OnDynamicNodeAttach(*this, *newInner, turn);
+            this->DynamicDetachFromMe(oldInner->GetNodeId(), 0);
+            this->DynamicAttachToMe(newInner->GetNodeId(), 0);
 
-            return;
+            return UpdateResult::shifted;
         }
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
+        this->Events().insert(this->Events().end(), inner_->Events().begin(), inner_->Events().end());
 
-        this->events_.insert(
-            this->events_.end(),
-            inner_->Events().begin(),
-            inner_->Events().end());
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (this->events_.size() > 0)
-            Engine::OnNodePulse(*this, turn);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
 private:
-    std::shared_ptr<SignalNode<D,TOuter>>       outer_;
-    std::shared_ptr<EventStreamNode<D,TInner>>  inner_;
+    std::shared_ptr<SignalNode<TOuter>>       outer_;
+    std::shared_ptr<EventStreamNode<TInner>>  inner_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedEventTransformNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TIn,
-    typename TOut,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedEventTransformNode :
-    public EventStreamNode<D,TOut>
+template <typename TOut, typename TIn, typename F, typename ... TSyncs>
+class SyncedEventTransformNode : public EventStreamNode<TOut>
 {
-    using Engine = typename SyncedEventTransformNode::Engine;
-
 public:
-    template <typename F>
-    SyncedEventTransformNode(const std::shared_ptr<EventStreamNode<D,TIn>>& source, F&& func, 
-                             const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedEventTransformNode::EventStreamNode( ),
-        source_( source ),
-        func_( std::forward<F>(func) ),
-        deps_( deps ... )
+    template <typename U>
+    SyncedEventTransformNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedEventTransformNode::EventStreamNode( group ),
+        dep_( dep ),
+        func_( std::forward<U>(func) ),
+        syncs_( syncs ... )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *source);
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedEventTransformNode()
     {
-        Engine::OnNodeDetach(*this, *source_);
-
-        apply(
-            DetachFunctor<D,SyncedEventTransformNode,
-                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-            deps_);
-
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update() override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+        //this->SetCurrentTurn(turn, true);
 
-        this->SetCurrentTurn(turn, true);
         // Update of this node could be triggered from deps,
         // so make sure source doesnt contain events from last turn
-        source_->SetCurrentTurn(turn);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        // Don't time if there is nothing to do
-        if (! source_->Events().empty())
-        {// timer
-            using TimerT = typename SyncedEventTransformNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, source_->Events().size() );
-
-            for (const auto& e : source_->Events())
-                this->events_.push_back(apply(
-                        [this, &e] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-                        {
-                            return func_(e, args->ValueRef() ...);
-                        },
-                        deps_));
-                    
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        // source_->SetCurrentTurn(turn);
+
+        for (const auto& e : dep_->Events())
+            this->Events().push_back(apply([this, &e] (const auto& ... syncs) { return this->func_(e, syncs->ValueRef() ...); }, syncHolder_));
+
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "SyncedEventTransformNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+    virtual const char* GetNodeType() const override
+        { return "SyncedEventTransform"; }
+
+    virtual int DependencyCount() const override
+        { return 1 + sizeof...(TSyncs); }
 
 private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
+    std::shared_ptr<EventStreamNode<TIn>>   dep_;
 
-    std::shared_ptr<EventStreamNode<D,TIn>>   source_;
+    F func_;
 
-    TFunc       func_;
-    DepHolderT  deps_;
+    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedEventFilterNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedEventFilterNode :
-    public EventStreamNode<D,E>
+template <typename T, typename F, typename ... TSyncs>
+class SyncedEventFilterNode : public EventStreamNode<T>
 {
-    using Engine = typename SyncedEventFilterNode::Engine;
-
 public:
-    template <typename F>
-    SyncedEventFilterNode(const std::shared_ptr<EventStreamNode<D,E>>& source, F&& filter, 
-                          const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedEventFilterNode::EventStreamNode( ),
-        source_( source ),
-        filter_( std::forward<F>(filter) ),
-        deps_(deps ... )
+    template <typename U>
+    SyncedEventFilterNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<T>>& dep, U&& pred, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedEventFilterNode::EventStreamNode( group ),
+        dep_( dep ),
+        pred_( std::forward<F>(pred) ),
+        syncs_( syncs ... )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *source);
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedEventFilterNode()
     {
-        Engine::OnNodeDetach(*this, *source_);
-
-        apply(
-            DetachFunctor<D,SyncedEventFilterNode,
-                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-            deps_);
-
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update() override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+        // this->SetCurrentTurn(turn, true);
 
-        this->SetCurrentTurn(turn, true);
         // Update of this node could be triggered from deps,
         // so make sure source doesnt contain events from last turn
-        source_->SetCurrentTurn(turn);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        // Don't time if there is nothing to do
-        if (! source_->Events().empty())
-        {// timer
-            using TimerT = typename SyncedEventFilterNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, source_->Events().size() );
-
-            for (const auto& e : source_->Events())
-                if (apply(
-                        [this, &e] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-                        {
-                            return filter_(e, args->ValueRef() ...);
-                        },
-                        deps_))
-                    this->events_.push_back(e);
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        //source_->SetCurrentTurn(turn);
+
+        for (const auto& e : dep_->Events())
+            if (apply([this, &e] (const auto& ... syncs) { return this->func_(e, syncs->ValueRef() ...); }, syncHolder_))
+                this->Events().push_back(e);
+
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "SyncedEventFilterNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+    virtual const char* GetNodeType() const override
+        { return "SyncedEventFilter"; }
 
-    virtual bool IsHeavyweight() const override
-    {
-        return this->IsUpdateThresholdExceeded();
-    }
+    virtual int DependencyCount() const override
+        { return 1 + sizeof...(TSyncs); }
 
 private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
+    std::shared_ptr<EventStreamNode<TIn>>   dep_;
 
-    std::shared_ptr<EventStreamNode<D,E>>   source_;
+    F pred_;
 
-    TFunc       filter_;
-    DepHolderT  deps_;
+    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventProcessingNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TIn,
-    typename TOut,
-    typename TFunc
->
-class EventProcessingNode :
-    public EventStreamNode<D,TOut>
+template <typename TOut, typename TIn, typename F>
+class EventProcessingNode : public EventStreamNode<TOut>
 {
-    using Engine = typename EventProcessingNode::Engine;
-
 public:
-    template <typename F>
-    EventProcessingNode(const std::shared_ptr<EventStreamNode<D,TIn>>& source, F&& func) :
-        EventProcessingNode::EventStreamNode( ),
-        source_( source ),
-        func_( std::forward<F>(func) )
+    template <typename U>
+    EventProcessingNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func) :
+        EventProcessingNode::EventStreamNode( group ),
+        dep_( dep ),
+        func_( std::forward<U>(func) )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *source);
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
     }
 
     ~EventProcessingNode()
     {
-        Engine::OnNodeDetach(*this, *source_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update() override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        this->SetCurrentTurn(turn, true);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        {// timer
-            using TimerT = typename EventProcessingNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, source_->Events().size() );
-
-            func_(
-                EventRange<TIn>( source_->Events() ),
-                std::back_inserter(this->events_));
-
-        }// ~timer
+        //this->SetCurrentTurn(turn, true);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+        func_(EventRange<TIn>( source_->Events() ), std::back_inserter(this->Events()));
 
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "EventProcessingNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
+    virtual const char* GetNodeType() const override
+        { return "EventProcessing"; }
+
+    virtual int DependencyCount() const override
+        { return 1; }
 
 private:
     std::shared_ptr<EventStreamNode<D,TIn>>   source_;
@@ -858,224 +512,155 @@ class EventProcessingNode :
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedEventProcessingNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TIn,
-    typename TOut,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedEventProcessingNode :
-    public EventStreamNode<D,TOut>
+template <typename TOut, typename TIn, typename F, typename ... TSyncs>
+class SyncedEventProcessingNode : public EventStreamNode<TOut>
 {
-    using Engine = typename SyncedEventProcessingNode::Engine;
-
 public:
-    template <typename F>
-    SyncedEventProcessingNode(const std::shared_ptr<EventStreamNode<D,TIn>>& source, F&& func, 
-                             const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedEventProcessingNode::EventStreamNode( ),
-        source_( source ),
-        func_( std::forward<F>(func) ),
-        deps_( deps ... )
+    template <typename U>
+    SyncedEventProcessingNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedEventProcessingNode::EventStreamNode( group ),
+        dep_( dep ),
+        func_( std::forward<U>(func) ),
+        syncs_( syncs ... )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *source);
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedEventProcessingNode()
     {
-        Engine::OnNodeDetach(*this, *source_);
-
-        apply(
-            DetachFunctor<D,SyncedEventProcessingNode,
-                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-            deps_);
-
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update() override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        this->SetCurrentTurn(turn, true);
+        //this->SetCurrentTurn(turn, true);
         // Update of this node could be triggered from deps,
         // so make sure source doesnt contain events from last turn
-        source_->SetCurrentTurn(turn);
+        //source_->SetCurrentTurn(turn);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        // Don't time if there is nothing to do
-        if (! source_->Events().empty())
-        {// timer
-            using TimerT = typename SyncedEventProcessingNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, source_->Events().size() );
-
-            apply(
-                [this] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-                {
-                    func_(
-                        EventRange<TIn>( source_->Events() ),
-                        std::back_inserter(this->events_),
-                        args->ValueRef() ...);
-                },
-                deps_);
-
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+        apply(
+            [this] (const auto& ... syncs)
+            {
+                func_(EventRange<TIn>( source_->Events() ), std::back_inserter(this->Events()), syncs->ValueRef() ...);
+            },
+            syncHolder_);
 
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "SycnedEventProcessingNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+    virtual const char* GetNodeType() const override
+        { return "SycnedEventProcessing"; }
+
+    virtual int DependencyCount() const override
+        { return 1 + sizeof...(TSyncs); }
 
 private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
+    std::shared_ptr<EventStreamNode<TIn>>   dep_;
 
-    std::shared_ptr<EventStreamNode<D,TIn>>   source_;
+    F func_;
 
-    TFunc       func_;
-    DepHolderT  deps_;
+    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventJoinNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename ... TValues
->
-class EventJoinNode :
-    public EventStreamNode<D,std::tuple<TValues ...>>
+template <typename ... Ts>
+class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 {
-    using Engine = typename EventJoinNode::Engine;
-    using TurnT = typename Engine::TurnT;
-
 public:
-    EventJoinNode(const std::shared_ptr<EventStreamNode<D,TValues>>& ... sources) :
-        EventJoinNode::EventStreamNode( ),
-        slots_( sources ... )
+    EventJoinNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<Ts>>& ... deps) :
+        EventJoinNode::EventStreamNode( group ),
+        slots_( deps ... )
     {
-        Engine::OnNodeCreate(*this);
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *sources));
+        this->RegisterMe();
+        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
     ~EventJoinNode()
     {
-        apply(
-            [this] (Slot<TValues>& ... slots) {
-                REACT_EXPAND_PACK(Engine::OnNodeDetach(*this, *slots.Source));
-            },
-            slots_);
-
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(slots.source->GetNodeId())); }, slots_);
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update() override
     {
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
+        //this->SetCurrentTurn(turn, true);
 
-        this->SetCurrentTurn(turn, true);
+        // Move events into buffers
+        apply([this, &turn] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turn, slots)); }, slots_);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        // Don't time if there is nothing to do
-        {// timer
-            size_t count = 0;
-            using TimerT = typename EventJoinNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, count );
+        while (true)
+        {
+            bool isReady = true;
 
-            // Move events into buffers
+            // All slots ready?
             apply(
-                [this, &turn] (Slot<TValues>& ... slots) {
-                    REACT_EXPAND_PACK(fetchBuffer(turn, slots));
+                [this,&isReady] (Slot<Ts>& ... slots) {
+                    // Todo: combine return values instead
+                    REACT_EXPAND_PACK(CheckSlot(slots, isReady));
                 },
                 slots_);
 
-            while (true)
-            {
-                bool isReady = true;
-
-                // All slots ready?
-                apply(
-                    [this,&isReady] (Slot<TValues>& ... slots) {
-                        // Todo: combine return values instead
-                        REACT_EXPAND_PACK(checkSlot(slots, isReady));
-                    },
-                    slots_);
-
-                if (!isReady)
-                    break;
-
-                // Pop values from buffers and emit tuple
-                apply(
-                    [this] (Slot<TValues>& ... slots) {
-                        this->events_.emplace_back(slots.Buffer.front() ...);
-                        REACT_EXPAND_PACK(slots.Buffer.pop_front());
-                    },
-                    slots_);
-            }
-
-            count = this->events_.size();
-
-        }// ~timer
+            if (!isReady)
+                break;
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+            // Pop values from buffers and emit tuple
+            apply(
+                [this] (Slot<Ts>& ... slots)
+                {
+                    this->Events().emplace_back(slots.buffer.front() ...);
+                    REACT_EXPAND_PACK(slots.buffer.pop_front());
+                },
+                slots_);
+        }
 
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "EventJoinNode"; }
-    virtual int         DependencyCount() const override    { return sizeof...(TValues); }
+    virtual const char* GetNodeType() const override
+        { return "EventJoin"; }
+
+    virtual int DependencyCount() const override
+        { return sizeof...(Ts); }
 
 private:
-    template <typename T>
+    template <typename U>
     struct Slot
     {
-        Slot(const std::shared_ptr<EventStreamNode<D,T>>& src) :
-            Source( src )
-        {}
+        Slot(const std::shared_ptr<EventStreamNode<U>>& src) :
+            source( src )
+            { }
 
-        std::shared_ptr<EventStreamNode<D,T>>   Source;
-        std::deque<T>                           Buffer;
+        std::shared_ptr<EventStreamNode<U>>     source;
+        std::deque<U>                           buffer;
     };
 
-    template <typename T>
-    static void fetchBuffer(TurnT& turn, Slot<T>& slot)
+    template <typename U>
+    static void FetchBuffer(TurnT& turn, Slot<U>& slot)
     {
-        slot.Source->SetCurrentTurn(turn);
-
-        slot.Buffer.insert(
-            slot.Buffer.end(),
-            slot.Source->Events().begin(),
-            slot.Source->Events().end());
+        //slot.Source->SetCurrentTurn(turn);
+        slot.buffer.insert(slot.buffer.end(), slot.source->Events().begin(), slot.source->Events().end());
     }
 
     template <typename T>
-    static void checkSlot(Slot<T>& slot, bool& isReady)
+    static void CheckSlot(Slot<T>& slot, bool& isReady)
     {
-        auto t = isReady && !slot.Buffer.empty();
+        bool t = isReady && !slot.buffer.empty();
         isReady = t;
     }
 
-    std::tuple<Slot<TValues>...>    slots_;
+    std::tuple<Slot<Ts>...> slots_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 66993500..404108d0 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -17,7 +17,8 @@
 #include "react/common/Util.h"
 #include "react/common/Timing.h"
 #include "react/common/Types.h"
-#include "react/detail/IReactiveEngine.h"
+#include "react/detail/IReactiveGroup.h"
+#include "react/detail/IReactiveNode.h"
 #include "react/detail/ObserverBase.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
@@ -84,28 +85,28 @@ struct DepCounter<N, First, Args...>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// NodeBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class NodeBase :
-    public D::Policy::Engine::NodeT,
-    public UpdateTimingPolicy<D,500>
+class NodeBase : public IReactiveNode
 {
 public:
-    using DomainT = D;
-    using Policy = typename D::Policy;
-    using Engine = typename D::Engine;
-    using NodeT = typename Engine::NodeT;
-    using TurnT = typename Engine::TurnT;
+    NodeBase(IReactiveGroup* group) : group_( group )
+        { }
 
-    NodeBase() = default;
-
-    // Nodes can't be copied
+    NodeBase(NodeBase&&) = delete;
+    NodeBase& operator=(NodeBase&&) = delete;
     NodeBase(const NodeBase&) = delete;
+    NodeBase& operator=(const NodeBase&) = delete;
     
-    virtual bool    IsInputNode() const override    { return false; }
-    virtual bool    IsOutputNode() const override   { return false; }
-    virtual bool    IsDynamicNode() const override  { return false; }
+    virtual bool IsInputNode() const override
+        { return false; }
+
+    virtual bool IsOutputNode() const override
+        { return false; }
+
+    virtual bool IsDynamicNode() const override
+        { return false; }
     
-    virtual bool    IsHeavyweight() const override  { return this->IsUpdateThresholdExceeded(); }
+    virtual bool IsHeavyweight() const override 
+        { return false; }
 
     void SetWeightHint(WeightHint weight)
     {
@@ -122,27 +123,38 @@ class NodeBase :
             break;
         }
     }
-};
 
-template <typename D>
-using NodeBasePtrT = std::shared_ptr<NodeBase<D>>;
+    NodeId GetNodeId() const
+        { return nodeId_; }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObservableNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class ObservableNode :
-    public NodeBase<D>,
-    public Observable<D>
-{
-public:
-    ObservableNode() = default;
+protected:
+    void RegisterMe()
+        { nodeId_ = group_->RegisterNode(); }
+    
+    void UnregisterMe()
+        { group_->UnregisterNode(nodeId_); }
+
+    void AttachToMe(NodeId otherNodeId)
+        { group_->OnNodeAttach(nodeId_, otherNodeId); }
+
+    void DetachFromMe(NodeId otherNodeId)
+        { group_->OnNodeDetach(nodeId_, otherNodeId); }
+
+    void DynamicAttachToMe(NodeId otherNodeId, TurnId turnId)
+        { group_->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
+
+    void DynamicDetachFromMe(NodeId otherNodeId, TurnId turnId)
+        { group_->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
+
+private:
+    NodeId          nodeId_;
+    IReactiveGroup* group_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Attach/detach helper functors
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename TNode, typename ... TDeps>
+template <typename TNode, typename ... TDeps>
 struct AttachFunctor
 {
     AttachFunctor(TNode& node) : MyNode( node ) {}
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 9ea74832..8f9424dc 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -27,14 +27,14 @@ bool Equals(const L& lhs, const R& rhs);
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
+template <typename T>
 class SignalNode : public ObservableNode
 {
 public:
     SignalNode() = default;
 
-    template <typename T>
-    explicit SignalNode(T&& value) :
+    template <typename U>
+    explicit SignalNode(U&& value) :
         SignalNode::ObservableNode( ),
         value_( std::forward<T>(value) )
     {}
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index d9782c0d..f2e9c00c 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -159,7 +159,6 @@
     <ClInclude Include="..\..\include\react\detail\DomainBase.h" />
     <ClInclude Include="..\..\include\react\detail\EventBase.h" />
     <ClInclude Include="..\..\include\react\detail\graph\ObserverNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\ContinuationNodes.h" />
     <ClInclude Include="..\..\include\react\detail\ObserverBase.h" />
     <ClInclude Include="..\..\include\react\detail\ReactiveInput.h" />
     <ClInclude Include="..\..\include\react\detail\Defs.h" />
@@ -167,9 +166,8 @@
     <ClInclude Include="..\..\include\react\detail\graph\AlgorithmNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\ReactorNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\IReactiveEngine.h" />
+    <ClInclude Include="..\..\include\react\detail\IReactiveGroup.h" />
     <ClInclude Include="..\..\include\react\detail\IReactiveNode.h" />
     <ClInclude Include="..\..\include\react\detail\ReactiveBase.h" />
     <ClInclude Include="..\..\include\react\detail\SignalBase.h" />
@@ -189,7 +187,6 @@
     <ClInclude Include="..\..\include\react\Algorithm.h" />
     <ClInclude Include="..\..\include\react\Event.h" />
     <ClInclude Include="..\..\include\react\Observer.h" />
-    <ClInclude Include="..\..\include\react\Reactor.h" />
     <ClInclude Include="..\..\include\react\Signal.h" />
     <ClInclude Include="..\..\include\react\TypeTraits.h" />
   </ItemGroup>
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index 7de3201b..2b7a6008 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -57,9 +57,6 @@
     <ClInclude Include="..\..\include\react\common\Concurrency.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Reactor.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\engine\SubtreeEngine.h">
       <Filter>Header Files\engine</Filter>
     </ClInclude>
@@ -69,9 +66,6 @@
     <ClInclude Include="..\..\include\react\detail\EngineBase.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\IReactiveEngine.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\IReactiveNode.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
@@ -81,9 +75,6 @@
     <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\ReactorNodes.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
@@ -141,15 +132,15 @@
     <ClInclude Include="..\..\include\react\engine\PulsecountEngine.h">
       <Filter>Header Files\engine</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\ContinuationNodes.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\common\RefCounting.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
     <ClInclude Include="..\..\include\react\detail\DomainBase.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\react\detail\IReactiveGroup.h">
+      <Filter>Header Files\detail</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\src\logging\EventLog.cpp">

From d13b3f47f8ebfcbd8062ecbfdd51db60796b885d Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 4 Aug 2016 16:16:05 +0200
Subject: [PATCH 30/75] Major redesign WIP.

---
 examples/src/BasicSignals.cpp                 |  37 +-
 include/react/API.h                           | 118 ++++
 include/react/Algorithm.h                     |  22 +-
 include/react/Event.h                         | 465 ++++++++-------
 include/react/{Domain.h => Group.h}           | 210 ++++---
 include/react/Observer.h                      |   6 +-
 include/react/Signal.h                        | 321 ++++++----
 include/react/TypeTraits.h                    |  92 ---
 include/react/common/Containers.h             | 148 +++++
 include/react/common/TopoQueue.h              |  20 +-
 include/react/common/Util.h                   |  52 +-
 include/react/detail/Defs.h                   |  13 -
 include/react/detail/DomainBase.h             | 265 ---------
 include/react/detail/EventBase.h              |  49 --
 include/react/detail/IReactiveGraph.h         | 100 ++++
 include/react/detail/IReactiveGroup.h         |  64 --
 include/react/detail/IReactiveNode.h          |  67 ---
 include/react/detail/ReactiveBase.h           | 158 -----
 include/react/detail/ReactiveInput.h          |  12 +-
 include/react/detail/SignalBase.h             |  65 --
 include/react/detail/graph/AlgorithmNodes.h   | 553 +++++++-----------
 .../react/detail/graph/ContinuationNodes.h    | 351 -----------
 include/react/detail/graph/EventNodes.h       | 418 ++++---------
 include/react/detail/graph/GraphBase.h        | 238 +-------
 include/react/detail/graph/ObserverNodes.h    | 338 +++--------
 include/react/detail/graph/PropagationMT.h    |   0
 include/react/detail/graph/PropagationST.h    | 284 +++++++++
 include/react/detail/graph/ReactorNodes.h     | 259 --------
 include/react/detail/graph/SignalNodes.h      | 346 ++++-------
 include/react/engine/PulsecountEngine.h       |   6 +-
 include/react/engine/SubtreeEngine.h          |   6 +-
 include/react/engine/ToposortEngine.h         |   6 +-
 project/msvc/CppReact.vcxproj                 |  19 +-
 project/msvc/CppReact.vcxproj.filters         |  81 +--
 src/engine/PulsecountEngine.cpp               |   6 +-
 src/engine/SubtreeEngine.cpp                  |   6 +-
 src/engine/ToposortEngine.cpp                 |   6 +-
 37 files changed, 1920 insertions(+), 3287 deletions(-)
 create mode 100644 include/react/API.h
 rename include/react/{Domain.h => Group.h} (52%)
 delete mode 100644 include/react/TypeTraits.h
 delete mode 100644 include/react/detail/DomainBase.h
 delete mode 100644 include/react/detail/EventBase.h
 create mode 100644 include/react/detail/IReactiveGraph.h
 delete mode 100644 include/react/detail/IReactiveGroup.h
 delete mode 100644 include/react/detail/IReactiveNode.h
 delete mode 100644 include/react/detail/ReactiveBase.h
 delete mode 100644 include/react/detail/SignalBase.h
 delete mode 100644 include/react/detail/graph/ContinuationNodes.h
 create mode 100644 include/react/detail/graph/PropagationMT.h
 create mode 100644 include/react/detail/graph/PropagationST.h
 delete mode 100644 include/react/detail/graph/ReactorNodes.h

diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index a5a82445..7f6943f2 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -11,10 +11,8 @@
 #include <utility>
 #include <vector>
 
-#include "react/Domain.h"
 #include "react/Signal.h"
-#include "react/Observer.h"
-
+/*
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Hello world
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -26,7 +24,7 @@ namespace example1
     // Defines a domain.
     // Each domain represents a separate dependency graph, managed by a dedicated propagation engine.
     // Reactives of different domains can not be combined.
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup
 
     // Define type aliases for the given domain in this namespace.
     // Now we can use VarSignalT instead of D::VarSignalT.
@@ -41,8 +39,8 @@ namespace example1
     namespace v1
     {
         // The two words
-        VarSignalT<string>  firstWord   = MakeVar<D>(string("Change"));
-        VarSignalT<string>  secondWord  = MakeVar<D>(string("me!"));
+        VarSignalT<string>  firstWord( string("Change") );
+        VarSignalT<string>  secondWord( string("me!") );
 
         SignalT<string>  bothWords = MakeSignal(With(firstWord,secondWord), concatFunc);
 
@@ -388,5 +386,32 @@ int main()
     example5::v2::Run();
     example5::v3::Run();
 
+    return 0;
+}
+
+*/
+
+using namespace react;
+
+int main()
+{
+    auto group = ReactiveGroup<shared>( );
+
+    auto sig1 = VarSignal<int, unique>( 1, group );
+    auto sig2 = VarSignal<int, shared>( 2, group );
+
+    sig1.Set(1);
+    sig1 <<= 1;
+
+    sig2.Modify([] (int& value) { value = 3; });
+
+    group.DoTransaction(
+        [&]
+        {
+            sig1 <<= 2;
+        });
+
+    auto sig3 = Signal<int, unique>( [] (auto a, auto b) { return a + b; }, sig1, sig2 );
+
     return 0;
 }
\ No newline at end of file
diff --git a/include/react/API.h b/include/react/API.h
new file mode 100644
index 00000000..b445b74c
--- /dev/null
+++ b/include/react/API.h
@@ -0,0 +1,118 @@
+
+//          Copyright Sebastian Jeckel 2016.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_API_H_INCLUDED
+#define REACT_API_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/Defs.h"
+#include "react/common/Util.h"
+
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// API constants
+///////////////////////////////////////////////////////////////////////////////////////////////////
+enum OwnershipPolicy
+{
+    unique,
+    shared
+};
+
+enum ThreadingPolicy
+{
+    sequential,
+    concurrent
+};
+
+enum class WeightHint
+{
+    automatic,
+    light,
+    heavy
+};
+
+enum class TransactionFlags
+{
+    none = 1 << 0,
+    allow_merging = 1 << 1
+};
+
+REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// API types
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Groups
+template <OwnershipPolicy = unique>
+class ReactiveGroup;
+
+// Signals
+template <typename T>
+class SignalBase;
+
+template <typename T>
+class VarSignalBase;
+
+template <typename T, OwnershipPolicy = unique>
+class Signal;
+
+template <typename T, OwnershipPolicy = unique>
+class VarSignal;
+
+// Events
+template <typename T>
+class EventBase;
+
+template <typename T>
+class EventSourceBase;
+
+template <typename T, OwnershipPolicy = unique>
+class Event;
+
+template <typename T, OwnershipPolicy = unique>
+class EventSource;
+
+enum class Token;
+
+// Observers
+class Observer;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Traits
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct IsSignal { static const bool value = false; };
+
+template <typename T, OwnershipPolicy ownership_policy>
+struct IsSignal<Signal<T, ownership_policy>> { static const bool value = true; };
+
+template <typename T, OwnershipPolicy ownership_policy>
+struct IsSignal<VarSignal<T, ownership_policy>> { static const bool value = true; };
+
+template <typename T>
+struct IsEvent { static const bool value = false; };
+
+template <typename T, OwnershipPolicy ownership_policy>
+struct IsEvent<Event<T, ownership_policy>> { static const bool value = true; };
+
+template <typename T, OwnershipPolicy ownership_policy>
+struct IsEvent<EventSource<T, ownership_policy>> { static const bool value = true; };
+
+template <typename T>
+struct AsNonInputNode { using type = T; };
+
+template <typename T, OwnershipPolicy ownership_policy>
+struct AsNonInputNode<VarSignal<T, ownership_policy>> { using type = Signal<T, ownership_policy>; };
+
+template <typename T, OwnershipPolicy ownership_policy>
+struct AsNonInputNode<EventSource<T, ownership_policy>> { using type = Event<T, ownership_policy>; };
+
+/******************************************/ REACT_END /******************************************/
+
+#endif // REACT_TYPETRAITS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index b6da68af..e2a1f3a9 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -15,32 +15,16 @@
 #include <type_traits>
 #include <utility>
 
+#include "react/API.h"
 #include "react/detail/graph/AlgorithmNodes.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class Signal;
-
-template <typename T>
-class VarSignal;
-
-template <typename T>
-class Events;
-
-template <typename T>
-class EventSource;
-
-enum class Token;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Hold - Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename V>
-auto Hold(const Events<T>& events, V&& init) -> Signal<T>
+template <typename T, typename U>
+auto Hold(const Events<T>& events, U&& init) -> Signal<T>
 {
     using REACT_IMPL::HoldNode;
 
diff --git a/include/react/Event.h b/include/react/Event.h
index 599c2ad6..5af37093 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -10,72 +10,287 @@
 #pragma once
 
 #include "react/detail/Defs.h"
+#include "react/API.h"
+#include "react/Group.h"
 
 #include <memory>
 #include <type_traits>
 #include <utility>
 
-#include "react/Observer.h"
-#include "react/TypeTraits.h"
-#include "react/common/Util.h"
-#include "react/detail/EventBase.h"
+#include "react/detail/graph/EventNodes.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
+/// Events
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T = Token>
+class EventBase
+{
+private:
+    using NodeType = REACT_IMPL::EventStreamNode<T>;
+
+public:
+    EventBase() = default;
+
+    EventBase(const EventBase&) = default;
+    EventBase& operator=(const EventBase&) = default;
+
+    EventBase(EventBase&&) = default;
+    EventBase& operator=(EventBase&&) = default;
+
+    ~EventBase() = default;
+
+    // Node ctor
+    explicit EventBase(std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
+
+    auto Tokenize() const -> decltype(auto)
+        { return REACT::Tokenize(*this); }
+
+    /*template <typename ... Us>
+    auto Merge(Us&& ... deps) const -> decltype(auto)
+        { return REACT::Merge(*this, std::forward<Us>(deps) ...); }
+
+    template <typename F>
+    auto Filter(F&& pred) const -> decltype(auto)
+        { return REACT::Filter(std::forward<F>(pred), *this); }
+
+    template <typename F>
+    auto Transform(F&& pred) const -> decltype(auto)
+        { return REACT::Transform(*this, std::forward<F>(f)); }*/
+
+protected:
+    auto NodePtr() -> std::shared_ptr<NodeType>&
+        { return nodePtr_; }
+
+    auto NodePtr() const -> const std::shared_ptr<NodeType>&
+        { return nodePtr_; }
+
+    template <typename FIn, typename TIn>
+    auto CreateProcessingNode(FIn&& func, const EventBase<TIn>& dep) -> decltype(auto)
+    {
+        using F = typename std::decay<FIn>::type;
+        using ProcessingNodeType = REACT_IMPL::EventProcessingNode<T, TIn, F>;
+
+        return std::make_shared<ProcessingNodeType>(
+            REACT_IMPL::PrivateNodeInterface::GraphPtr(dep),
+            REACT_IMPL::PrivateNodeInterface::NodePtr(dep),
+            std::forward<F>(func));
+    }
+
+private:
+    std::shared_ptr<NodeType> nodePtr_;
+
+    friend struct REACT_IMPL::PrivateNodeInterface;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventSource
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T = Token>
+class EventSourceBase : public EventBase<T>
+{
+private:
+    using NodeType = REACT_IMPL::EventSourceNode<T>;
+
+public:
+    using EventBase::EventBase;
+
+    EventSourceBase() = default;
+
+    EventSourceBase(const EventSourceBase&) = default;
+    EventSourceBase& operator=(const EventSourceBase&) = default;
+
+    EventSourceBase(EventSourceBase&& other) = default;
+    EventSourceBase& operator=(EventSourceBase&& other) = default;
+
+    template <typename TGroup>
+    explicit EventSourceBase(const TGroup& group) :
+        EventSourceBase::EventBase( std::make_shared<NodeType>(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        { }
+    
+    void Emit(const T& value)
+        { EmitValue(value); }
+
+    void Emit(T&& value)
+        { EmitValue(std::move(value)); }
+
+    template <typename U = T, typename = typename std::enable_if<std::is_same<U,Token>::value>::type>
+    void Emit()
+        { EmitValue(Token::value); }
+
+    EventSourceBase& operator<<(const T& value)
+        { EmitValue(e); return *this; }
+
+    EventSourceBase& operator<<(T&& value)
+        { EmitValue(std::move(value)); return *this; }
+
+private:
+    template <typename U>
+    void EmitValue(U&& value)
+    {
+        using REACT_IMPL::NodeId;
+        using REACT_IMPL::IReactiveGraph;
+
+        NodeType* castedPtr = static_cast<NodeType*>(this->NodePtr().get());
+
+        NodeId nodeId = castedPtr->GetNodeId();
+        auto& graphPtr = NodePtr()->GraphPtr();
+        graphPtr->AddInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<U>(value)); });
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Event
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class EventStream;
+class Event<T, unique> : public EventBase<T>
+{
+public:
+    using EventBase::EventBase;
+
+    using ValueType = T;
+
+    Event() = delete;
+
+    Event(const Event&) = delete;
+    Event& operator=(const Event&) = delete;
+
+    Event(Event&&) = default;
+    Event& operator=(Event&&) = default;
+
+    template <typename F, typename U>
+    Event(F&& func, const EventBase<U>& dep) :
+        Event::EventBase( CreateProcessingNode(std::forward<F>(func), dep) )
+        { }
+};
 
 template <typename T>
-class EventSource;
+class Event<T, shared> : public EventBase<T>
+{
+public:
+    using EventBase::EventBase;
+
+    using ValueType = T;
+
+    Event() = delete;
+
+    Event(const Event&) = default;
+    Event& operator=(const Event&) = default;
+
+    Event(Event&&) = default;
+    Event& operator=(Event&&) = default;
+
+    Event(Event<T, unique>&& other) :
+        Event::EventBase( std::move(other) )
+        { }
+
+    Event& operator=(Event<T, unique>&& other)
+        { Event::EventBase::operator=(std::move(other)); return *this; }
+
+    template <typename F, typename U>
+    Event(F&& func, const EventBase<U>& dep) :
+        Event::EventBase( CreateProcessingNode(std::forward<F>(func), dep) )
+        { }
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventSource
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+class EventSource<T, unique> : public EventSourceBase<T>
+{
+public:
+    using EventSourceBase::EventSourceBase;
+
+    using ValueType = T;
+
+    EventSource() = delete;
 
-enum class Token;
+    EventSource(const EventSource&) = delete;
+    EventSource& operator=(const EventSource&) = delete;
+
+    EventSource(EventSource&&) = default;
+    EventSource& operator=(EventSource&&) = default;
+};
 
 template <typename T>
-class Signal;
+class EventSource<T, shared> : public EventSourceBase<T>
+{
+public:
+    using EventSourceBase::EventSourceBase;
+
+    using ValueType = T;
+
+    EventSource() = delete;
+
+    EventSource(const EventSource&) = default;
+    EventSource& operator=(const EventSource&) = default;
 
-using REACT_IMPL::WeightHint;
+    EventSource(EventSource&&) = default;
+    EventSource& operator=(EventSource&&) = default;
+
+    EventSource(EventSource<T, unique>&& other) :
+        EventSource::EventSourceBase( std::move(other) )
+        { }
+
+    EventSource& operator=(EventSource<T, unique>&& other)
+        { EventSource::EventSourceBase::operator=(std::move(other)); return *this; }
+};
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TArg1,
-    typename ... TArgs,
-    typename E = TArg1
->
-auto Merge(const Events<TArg1>& arg1, const Events<TArgs>& ... args) -> Events<E>
+template <typename T = void, typename U1, typename ... Us>
+auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype(auto)
 {
-    using REACT_IMPL::EventOpNode;
+    using REACT_IMPL::EventMergeNode;
+    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateNodeInterface;
+
+    static_assert(sizeof...(Us) > 0, "Merge: 2+ arguments are required.");
 
-    static_assert(sizeof...(TArgs) > 0, "Merge: 2+ arguments are required.");
+    // If supplied, use merge type, otherwise default to common type.
+    using E = typename std::conditional<
+        std::is_same<T, void>::value,
+        typename std::common_type<U1, Us ...>::type,
+        T>::type;
 
-    return Events<E>(
-        std::make_shared<EventMergeNode<E>>(
-            GetNodePtr(arg1), GetNodePtr(args) ...));
+    const auto& graphPtr = GetCheckedGraphPtr(dep1, deps ...);
+
+    return Event<E, unique>(
+        std::make_shared<EventMergeNode<E, U1, Us ...>>(graphPtr, PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename E,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type
->
-auto Filter(const Events<E>& src, FIn&& filter) -> Events<E>
+template <typename F, typename T>
+auto Filter(F&& pred, const EventBase<T>& dep) -> Event<T, unique>
 {
-    using REACT_IMPL::EventOpNode;
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<T> out)
+        { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
 
-    return Events<E>(
-        std::make_shared<EventOpNode<E>>(
-            std::forward<FIn>(filter), GetNodePtr(src)));
+    return Event<T, unique>(std::move(filterFunc), dep);
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Transform
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T, typename F, typename U>
+auto Transform(F&& op, const EventBase<U>& dep) -> Event<T, unique>
+{
+    auto transformFunc = [capturedPred = std::forward<F>(op)] (EventRange<U> inRange, EventSink<T> out)
+        { std::transform(inRange.begin(), inRange.end(), out, pred); };
+
+    return Event<T, unique>(std::move(transformFunc), dep);
+}
+
+#if 0
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -115,24 +330,7 @@ auto Filter(const Events<E>& source, const SignalPack<TDepValues...>& depPack, F
         depPack.Data);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Transform
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TIn,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type,
-    typename TOut = typename std::result_of<F(TIn)>::type
->
-auto Transform(const Events<TIn>& src, FIn&& func) -> Events<TOut>
-{
-    using REACT_IMPL::EventOpNode;
 
-    return Events<TOut>(
-        std::make_shared<EventOpNode<TOut>>(
-            std::forward<FIn>(func), GetNodePtr(src)));
-}
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Transform - Synced
@@ -174,28 +372,6 @@ auto Transform(const Events<TIn>& source, FIn&& func, const Signal<TDepValues>&
         depPack.Data);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Process
-///////////////////////////////////////////////////////////////////////////////////////////////////
-using REACT_IMPL::EventRange;
-using REACT_IMPL::EventEmitter;
-
-template
-<
-    typename TOut,
-    typename TIn,
-    typename FIn,
-    typename F = typename std::decay<FIn>::type
->
-auto Process(const Events<TIn>& src, FIn&& func) -> Events<TOut>
-{
-    using REACT_IMPL::EventProcessingNode;
-
-    return Events<TOut>(
-        std::make_shared<EventProcessingNode<D,TIn,TOut,F>>(
-            GetNodePtr(src), std::forward<FIn>(func)));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Process - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -279,155 +455,14 @@ auto Tokenize(T&& source) -> decltype(auto)
     return Transform(source, Tokenizer{ });
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Events
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T = Token>
-class Events : public REACT_IMPL::EventStreamBase<T>
-{
-private:
-    using NodeType     = REACT_IMPL::EventStreamNode<T>;
-    using NodePtrType  = std::shared_ptr<NodeType>;
-
-public:
-    using ValueType = T;
-
-    // Default ctor
-    Events() = default;
-
-    // Copy ctor
-    Events(const Events&) = default;
-
-    // Move ctor
-    Events(Events&& other) = default;
-
-    // Node ctor
-    explicit Events(NodePtrT&& nodePtr) = default;
-
-    // Copy assignment
-    Events& operator=(const Events&) = default;
-
-    // Move assignment
-    Events& operator=(Events&& other) = default;
-
-    bool Equals(const Events& other) const
-    {
-        return Events::EventStreamBase::Equals(other);
-    }
-
-    bool IsValid() const
-    {
-        return Events::EventStreamBase::IsValid();
-    }
-
-    void SetWeightHint(WeightHint weight)
-    {
-        Events::EventStreamBase::SetWeightHint(weight);
-    }
-
-    auto Tokenize() const -> decltype(auto)
-    {
-        return REACT::Tokenize(*this);
-    }
-
-    template <typename ... TArgs>
-    auto Merge(TArgs&& ... args) const -> decltype(auto)
-    {
-        return REACT::Merge(*this, std::forward<TArgs>(args) ...);
-    }
-
-    template <typename F>
-    auto Filter(F&& f) const -> decltype(auto)
-    {
-        return REACT::Filter(*this, std::forward<F>(f));
-    }
-
-    template <typename F>
-    auto Transform(F&& f) const -> decltype(auto)
-    {
-        return REACT::Transform(*this, std::forward<F>(f));
-    }
-
-    template <typename E = Token>
-    static auto Create() -> EventSource<E>
-    {
-        using REACT_IMPL::EventSourceNode;
-
-        return EventSource<E>(std::make_shared<EventSourceNode<E>>());
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventSource
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T = Token>
-class EventSource : public Events<T>
-{
-private:
-    using NodeType     = REACT_IMPL::EventSourceNode<T>;
-    using NodePtrType  = std::shared_ptr<NodeType>;
-
-public:
-    // Default ctor
-    EventSource() = default;
-
-    // Copy ctor
-    EventSource(const EventSource&) = default;
-
-    // Move ctor
-    EventSource(EventSource&& other) = default;
-
-    // Node ctor
-    explicit EventSource(NodePtrT&& nodePtr) :
-        EventSource::Events( std::move(nodePtr) )
-    {}
-
-    // Copy assignemnt
-    EventSource& operator=(const EventSource&) = default;
-
-    // Move assignment
-    EventSource& operator=(EventSource&& other) = default;
-
-    // Explicit emit
-    void Emit(const T& e) const     { EventSource::EventStreamBase::emit(e); }
-    void Emit(T&& e) const          { EventSource::EventStreamBase::emit(std::move(e)); }
-
-    void Emit() const
-    {
-        static_assert(std::is_same<E,Token>::value, "Can't emit on non token stream.");
-        EventSource::EventStreamBase::emit(Token::value);
-    }
-
-    // Function object style
-    void operator()(const E& e) const   { EventSource::EventStreamBase::emit(e); }
-    void operator()(E&& e) const        { EventSource::EventStreamBase::emit(std::move(e)); }
-
-    void operator()() const
-    {
-        static_assert(std::is_same<T,Token>::value, "Can't emit on non token stream.");
-        EventSource::EventStreamBase::emit(Token::value);
-    }
-
-    // Stream style
-    const EventSource& operator<<(const T& e) const
-    {
-        EventSource::EventStreamBase::emit(e);
-        return *this;
-    }
-
-    const EventSource& operator<<(T&& e) const
-    {
-        EventSource::EventStreamBase::emit(std::move(e));
-        return *this;
-    }
-};
+#endif
 
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 template <typename L, typename R>
-bool Equals(const Events<L>& lhs, const Events<R>& rhs)
+bool Equals(const EventBase<L>& lhs, const EventBase<R>& rhs)
 {
     return lhs.Equals(rhs);
 }
diff --git a/include/react/Domain.h b/include/react/Group.h
similarity index 52%
rename from include/react/Domain.h
rename to include/react/Group.h
index b1fae362..cf58e72a 100644
--- a/include/react/Domain.h
+++ b/include/react/Group.h
@@ -14,62 +14,25 @@
 #include <memory>
 #include <utility>
 
-#include "react/detail/DomainBase.h"
-#include "react/detail/ReactiveInput.h"
+#include "react/API.h"
+#include "react/Signal.h"
+//#include "react/Event.h"
 
-#include "react/detail/graph/ContinuationNodes.h"
+#include "react/detail/IReactiveGraph.h"
+#include "react/detail/graph/PropagationST.h"
 
-#ifdef REACT_ENABLE_LOGGING
-    #include "react/logging/EventLog.h"
-    #include "react/logging/EventRecords.h"
-#endif //REACT_ENABLE_LOGGING
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class Signal;
-
-template <typename T>
-class VarSignal;
-
-template <typename T>
-class Events;
-
-template <typename T>
-class EventSource;
-
-enum class Token;
+struct PrivateReactiveGroupInterface;
+struct PrivateConcurrentReactiveGroupInterface;
 
-class Observer;
+/****************************************/ REACT_IMPL_END /***************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Common types & constants
-///////////////////////////////////////////////////////////////////////////////////////////////////
-using REACT_IMPL::TransactionFlagsT;
-
-// ETransactionFlags
-using REACT_IMPL::ETransactionFlags;
-using REACT_IMPL::allow_merging;
-
-#ifdef REACT_ENABLE_LOGGING
-    using REACT_IMPL::EventLog;
-#endif //REACT_ENABLE_LOGGING
+/*****************************************/ REACT_BEGIN /*****************************************/
 
-// Domain modes
-using REACT_IMPL::EDomainMode;
-using REACT_IMPL::sequential;
-using REACT_IMPL::sequential_concurrent;
-using REACT_IMPL::parallel;
-using REACT_IMPL::parallel_concurrent;
 
-// Expose enum type so aliases for engines can be declared, but don't
-// expose the actual enum values as they are reserved for internal use.
-using REACT_IMPL::EPropagationMode;
 
-using REACT_IMPL::WeightHint;
+#if 0
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// TransactionStatus
@@ -134,7 +97,7 @@ void DoTransaction(F&& func)
 }
 
 template <typename D, typename F>
-void DoTransaction(TransactionFlagsT flags, F&& func)
+void DoTransaction(TransactionFlags flags, F&& func)
 {
     using REACT_IMPL::DomainSpecificInputManager;
     DomainSpecificInputManager<D>::Instance().DoTransaction(flags, std::forward<F>(func));
@@ -155,7 +118,7 @@ void AsyncTransaction(F&& func)
 }
 
 template <typename D, typename F>
-void AsyncTransaction(TransactionFlagsT flags, F&& func)
+void AsyncTransaction(TransactionFlags flags, F&& func)
 {
     static_assert(D::is_concurrent,
         "AsyncTransaction: Domain does not support concurrent input.");
@@ -188,45 +151,124 @@ void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& fu
         .AsyncTransaction(flags, status.statePtr_, std::forward<F>(func));
 }
 
-/******************************************/ REACT_END /******************************************/
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Domain definition macro
+/// ReactiveGroupBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-#define REACTIVE_DOMAIN(name, ...)                                                          \
-    struct name :                                                                           \
-        public REACT_IMPL::DomainBase<name, REACT_IMPL::DomainPolicy< __VA_ARGS__ >> {};    \
-    static REACT_IMPL::DomainInitializer<name> name ## _initializer_;
-
-/*
-    A brief reminder why the domain initializer is here:
-    Each domain has a couple of singletons (debug log, engine, input manager) which are
-    currently implemented as meyer singletons. From what I understand, these are thread-safe
-    in C++11, but not all compilers implement that yet. That's why a static initializer has
-    been added to make sure singleton creation happens before any multi-threaded access.
-    This implemenation is obviously inconsequential.
- */
+class ReactiveGroupBase
+{
+    using GraphType = REACT_IMPL::SingleThreadedGraph;
+
+public:
+    ReactiveGroupBase() :
+        graphPtr_( std::make_shared<GraphType>() )
+        {  }
+
+    ReactiveGroupBase(const ReactiveGroupBase&) = default;
+    ReactiveGroupBase& operator=(const ReactiveGroupBase&) = default;
+
+    ReactiveGroupBase(ReactiveGroupBase&& other) = default;
+    ReactiveGroupBase& operator=(ReactiveGroupBase&& other) = default;
+
+    ~ReactiveGroupBase() = default;
+
+    template <typename F>
+    void DoTransaction(F&& func)
+        { DoTransaction(TransactionFlags::none, std::forward<F>(func)); }
+
+    template <typename F>
+    void DoTransaction(TransactionFlags flags, F&& func)
+        { graphPtr_->DoTransaction(flags, std::forward<F>(func)); }
+
+protected:
+    auto GraphPtr() -> std::shared_ptr<GraphType>&
+        { return graphPtr_; }
+
+    auto GraphPtr() const -> const std::shared_ptr<GraphType>&
+        { return graphPtr_; }
+
+private:
+    std::shared_ptr<GraphType> graphPtr_;
+
+    friend struct REACT_IMPL::PrivateReactiveGroupInterface;
+};
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Define type aliases for given domain
+/// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-#define USING_REACTIVE_DOMAIN(name)                                                         \
-    template <typename S>                                                                   \
-    using SignalT = Signal<name,S>;                                                         \
-                                                                                            \
-    template <typename S>                                                                   \
-    using VarSignalT = VarSignal<name,S>;                                                   \
-                                                                                            \
-    template <typename E = Token>                                                           \
-    using EventsT = Events<name,E>;                                                         \
-                                                                                            \
-    template <typename E = Token>                                                           \
-    using EventSourceT = EventSource<name,E>;                                               \
-                                                                                            \
-    using ObserverT = Observer<name>;                                                       \
-                                                                                            \
-    using ScopedObserverT = ScopedObserver<name>;                                           \
-                                                                                            \
-    using ReactorT = Reactor<name>;
+template <>
+class ReactiveGroup<unique> : public ReactiveGroupBase
+{
+public:
+    ReactiveGroup() = default;
+
+    ReactiveGroup(const ReactiveGroup&) = delete;
+    ReactiveGroup& operator=(const ReactiveGroup&) = delete;
+
+    ReactiveGroup(ReactiveGroup&& other) = default;
+    ReactiveGroup& operator=(ReactiveGroup&& other) = default;
+};
+
+template <>
+class ReactiveGroup<shared> : public ReactiveGroupBase
+{
+public:
+    ReactiveGroup() = default;
+
+    ReactiveGroup(const ReactiveGroup&) = default;
+    ReactiveGroup& operator=(const ReactiveGroup&) = default;
+
+    ReactiveGroup(ReactiveGroup&& other) = default;
+    ReactiveGroup& operator=(ReactiveGroup&& other) = default;
+};
+
+/******************************************/ REACT_END /******************************************/
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+struct PrivateNodeInterface
+{
+    template <typename TBase>
+    static auto NodePtr(const TBase& base) -> const std::shared_ptr<typename TBase::NodeType>&
+        { return base.NodePtr(); }
+
+    template <typename TBase>
+    static auto NodePtr(TBase& base) -> std::shared_ptr<typename TBase::NodeType>&
+        { return base.NodePtr(); }
+
+    template <typename TBase>
+    static auto GraphPtr(const TBase& base) -> const std::shared_ptr<IReactiveGraph>&
+        { return base.NodePtr()->GraphPtr(); }
+
+    template <typename TBase>
+    static auto GraphPtr(TBase& base) -> std::shared_ptr<IReactiveGraph>&
+        { return base.NodePtr()->GraphPtr(); }
+};
+
+struct PrivateReactiveGroupInterface
+{
+    static auto GraphPtr(const ReactiveGroupBase& group) -> const std::shared_ptr<SingleThreadedGraph>&
+        { return group.GraphPtr(); }
+
+    static auto GraphPtr(ReactiveGroupBase& group) -> std::shared_ptr<SingleThreadedGraph>&
+        { return group.GraphPtr(); }
+};
+
+template <typename TBase1, typename ... TBases>
+static auto GetCheckedGraphPtr(const TBase1& dep1, const TBases& ... deps) -> const std::shared_ptr<IReactiveGraph>&
+{
+    const std::shared_ptr<IReactiveGraph>& graphPtr1 = PrivateNodeInterface::GraphPtr(dep1);
+
+    auto rawGraphPtrs = { PrivateNodeInterface::GraphPtr(deps).get() ... };
+
+    bool isSameGraphForAllDeps = std::all_of(rawGraphPtrs.begin(), rawGraphPtrs.end(), [&] (IReactiveGraph* p) { return p == graphPtr1.get(); });
+
+    REACT_ASSERT(isSameGraphForAllDeps, "All dependencies must belong to the same group.");
+
+    return graphPtr1;
+}
+
+/****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DOMAIN_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 17e72ebf..705d4ee9 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #ifndef REACT_OBSERVER_H_INCLUDED
 #define REACT_OBSERVER_H_INCLUDED
 
@@ -333,4 +335,6 @@ auto Observe(const Events<D,E>& subject,
 
 /******************************************/ REACT_END /******************************************/
 
-#endif // REACT_OBSERVER_H_INCLUDED
\ No newline at end of file
+#endif // REACT_OBSERVER_H_INCLUDED
+
+#endif
\ No newline at end of file
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 4bf28460..ea60ce3a 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -14,192 +14,267 @@
 #endif
 
 #include "react/detail/Defs.h"
+#include "react/API.h"
+#include "react/Group.h"
 
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
-#include "react/Observer.h"
-#include "react/TypeTraits.h"
-#include "react/detail/SignalBase.h"
+#include "react/detail/graph/SignalNodes.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
+/// SignalBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class Signal;
+class SignalBase
+{
+private:
+    using NodeType = REACT_IMPL::SignalNode<T>;
 
-template <typename T>
-class VarSignal;
+public:
+    SignalBase() = default;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TInnerValue>
-auto Flatten(const Signal<D,Signal<D,TInnerValue>>& outer)
-    -> Signal<D,TInnerValue>
-{
-    return Signal<D,TInnerValue>(
-        std::make_shared<REACT_IMPL::FlattenNode<D, Signal<D,TInnerValue>, TInnerValue>>(
-            GetNodePtr(outer), GetNodePtr(outer.Value())));
-}
+    SignalBase(const SignalBase&) = default;
+    SignalBase& operator=(const SignalBase&) = default;
+
+    SignalBase(SignalBase&&) = default;
+    SignalBase& operator=(SignalBase&&) = default;
+
+    ~SignalBase() = default;
+
+    // Internal node ctor
+    explicit SignalBase(std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
+
+    const T& Value() const
+        { return nodePtr_->Value(); }
+
+protected:
+    auto NodePtr() -> std::shared_ptr<NodeType>&
+        { return nodePtr_; }
+
+    auto NodePtr() const -> const std::shared_ptr<NodeType>&
+        { return nodePtr_; }
+
+    template <typename FIn, typename U1, typename ... Us>
+    auto CreateFuncNode(FIn&& func, const SignalBase<U1>& dep1, const SignalBase<Us>& ... deps) -> decltype(auto)
+    {
+        using F = typename std::decay<FIn>::type;
+        using FuncNodeType = REACT_IMPL::SignalFuncNode<T, F, U1, Us ...>;
+
+        return std::make_shared<FuncNodeType>(
+            REACT_IMPL::GetCheckedGraphPtr(dep1, deps ...),
+            std::forward<FIn>(func),
+            REACT_IMPL::PrivateNodeInterface::NodePtr(dep1), REACT_IMPL::PrivateNodeInterface::NodePtr(deps) ...);
+    }
+
+private:
+    std::shared_ptr<NodeType> nodePtr_;
+
+    friend struct REACT_IMPL::PrivateNodeInterface;
+};
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signal
+/// VarSignalBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class Signal : public REACT_IMPL::SignalBase<T>
+class VarSignalBase : public SignalBase<T>
 {
-private:
-    using NodeType     = REACT_IMPL::SignalNode<T>;
-    using NodePtrType  = std::shared_ptr<NodeType>;
-
 public:
-    using ValueType = T;
+    using SignalBase::SignalBase;
 
-    // Default ctor
-    Signal() = default;
+    VarSignalBase() = default;
 
-    // Copy ctor
-    Signal(const Signal&) = default;
+    VarSignalBase(const VarSignalBase&) = default;
+    VarSignalBase& operator=(const VarSignalBase&) = default;
 
-    // Move ctor
-    Signal(Signal&& other) = default;
+    VarSignalBase(VarSignalBase&&) = default;
+    VarSignalBase& operator=(VarSignalBase&&) = default;
 
-    // Node ctor
-    explicit Signal(NodePtrType&& nodePtr) :
-        Signal::SignalBase( std::move(nodePtr) )
-    {}
+    void Set(const T& newValue)
+        { SetValue(newValue); }
 
-    // Copy assignment
-    Signal& operator=(const Signal&) = default;
+    void Set(T&& newValue)
+        { SetValue(std::move(newValue)); }
 
-    // Move assignment
-    Signal& operator=(Signal&& other) = default;
+    void operator<<=(const T& newValue)
+        { SetValue(newValue); }
 
-    const S& Get() const        { return Signal::SignalBase::getValue(); }
-    const S& operator()() const { return Signal::SignalBase::getValue(); }
+    void operator<<=(T&& newValue)
+        { SetValue(std::move(newValue)); }
 
-    bool Equals(const Signal& other) const
-    {
-        return Signal::SignalBase::Equals(other);
-    }
+    template <typename F>
+    void Modify(const F& func)
+        { ModifyValue(func); }
 
-    bool IsValid() const
+protected:
+    template <typename U, typename TGroup>
+    auto CreateVarNode(U&& value, const TGroup& group) -> decltype(auto)
     {
-        return Signal::SignalBase::IsValid();
+        using VarNodeType = REACT_IMPL::VarSignalNode<T>;
+        return std::make_shared<VarNodeType>(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<U>(value));
     }
 
-    void SetWeightHint(WeightHint weight)
+private:
+    template <typename U>
+    void SetValue(U&& newValue)
     {
-        Signal::SignalBase::SetWeightHint(weight);
-    }
+        using REACT_IMPL::NodeId;
+        using REACT_IMPL::IReactiveGraph;
+        using VarNodeType = REACT_IMPL::VarSignalNode<T>;
 
-    S Flatten() const
-    {
-        static_assert(IsSignal<S>::value || IsEvent<S>::value,
-            "Flatten requires a Signal or Events value type.");
-        return REACT::Flatten(*this);
+        VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
+
+        NodeId nodeId = castedPtr->GetNodeId();
+        auto& graphPtr = NodePtr()->GraphPtr();
+        graphPtr->AddInput(nodeId, [castedPtr, &newValue] { castedPtr->SetValue(std::forward<U>(newValue)); });
     }
 
-    template
-    <
-        typename ... Ts,
-        typename FIn,
-        typename F = typename std::decay<FIn>::type
-    >
-    static auto Create(FIn&& func, const Signal<TS>& ... args) -> Signal<S>
+    template <typename F>
+    void ModifyValue(const F& func)
     {
-        return Signal<S>(
-            std::make_shared<REACT_IMPL::SignalFuncNode<S, F>>(
-                std::forward<FIn>(func), GetNodePtr(args) ...));
+        using REACT_IMPL::NodeId;
+        using REACT_IMPL::IReactiveGraph;
+        using VarNodeType = REACT_IMPL::VarSignalNode<T>;
+
+        VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
+        
+        NodeId nodeId = castedPtr->GetNodeId();
+        auto& graphPtr = castedPtr->GraphPtr();
+        graphPtr->AddInput(nodeId, [castedPtr, &func] { castedPtr->ModifyValue(func); });
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// VarSignal
+/// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class VarSignal : public Signal<S>
+template <typename T>
+class Signal<T, unique> : public SignalBase<T>
 {
-private:
-    using NodeT     = REACT_IMPL::VarNode<S>;
-    using NodePtrT  = std::shared_ptr<NodeT>;
+public:
+    using SignalBase::SignalBase;
+
+    using ValueType = T;
+
+    Signal() = delete;
+
+    Signal(const Signal&) = delete;
+    Signal& operator=(const Signal&) = delete;
+
+    Signal(Signal&&) = default;
+    Signal& operator=(Signal&&) = default;
+
+    template <typename F, typename ... Us>
+    Signal(F&& func, const SignalBase<Us>& ... deps) :
+        SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
+        { }
+};
+
+template <typename T>
+class Signal<T, shared> : public SignalBase<T>
+{
+public:
+    using SignalBase::SignalBase;
+
+    using ValueType = T;
+
+    Signal() = delete;
+
+    Signal(const Signal&) = default;
+    Signal& operator=(const Signal&) = default;
+
+    Signal(Signal&&) = default;
+    Signal& operator=(Signal&&) = default;
+
+    Signal(Signal<T, unique>&& other) :
+        Signal::SignalBase( std::move(other) )
+        { }
+
+    Signal& operator=(Signal<T, unique>&& other)
+        { Signal::SignalBase::operator=(std::move(other)); return *this; }
+
+    template <typename F, typename ... Us>
+    Signal(F&& func, const SignalBase<Us>& ... deps) :
+        Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
+        { }
+};
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Signal
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+class VarSignal<T, unique> : public VarSignalBase<T>
+{
 public:
-    // Default ctor
-    VarSignal() = default;
+    using VarSignalBase::VarSignalBase;
 
-    // Copy ctor
-    VarSignal(const VarSignal&) = default;
+    using ValueType = T;
 
-    // Move ctor
-    VarSignal(VarSignal&& other) :
-        VarSignal::Signal( std::move(other) )
-    {}
+    VarSignal() = delete;
 
-    // Node ctor
-    explicit VarSignal(NodePtrT&& nodePtr) :
-        VarSignal::Signal( std::move(nodePtr) )
-    {}
+    VarSignal(const VarSignal&) = delete;
+    VarSignal& operator=(const VarSignal&) = delete;
 
-    // Copy assignment
-    VarSignal& operator=(const VarSignal&) = default;
+    VarSignal(VarSignal&&) = default;
+    VarSignal& operator=(VarSignal&&) = default;
 
-    // Move assignment
-    VarSignal& operator=(VarSignal&& other)
-    {
-        VarSignal::SignalBase::operator=( std::move(other) );
-        return *this;
-    }
+    template <typename U, typename TGroup>
+    VarSignal(U&& value, const TGroup& group) :
+        VarSignal::VarSignalBase( CreateVarNode(std::forward<U>(value), group) )
+        { }
+};
 
-    void Set(const S& newValue) const
-    {
-        VarSignal::SignalBase::setValue(newValue);
-    }
+template <typename T>
+class VarSignal<T, shared> : public VarSignalBase<T>
+{
+public:
+    using VarSignalBase::VarSignalBase;
 
-    void Set(S&& newValue) const
-    {
-        VarSignal::SignalBase::setValue(std::move(newValue));
-    }
+    using ValueType = T;
 
-    const VarSignal& operator<<=(const S& newValue) const
-    {
-        VarSignal::SignalBase::setValue(newValue);
-        return *this;
-    }
+    VarSignal() = delete;
 
-    const VarSignal& operator<<=(S&& newValue) const
-    {
-        VarSignal::SignalBase::setValue(std::move(newValue));
-        return *this;
-    }
+    VarSignal(const VarSignal&) = default;
+    VarSignal& operator=(const VarSignal&) = default;
 
-    template <typename F>
-    void Modify(const F& func) const
-    {
-        VarSignal::SignalBase::modifyValue(func);
-    }
+    VarSignal(VarSignal&&) = default;
+    VarSignal& operator=(VarSignal&&) = default;
 
-    /// Create
-    template <typename V>
-    static auto Create(V&& value) -> VarSignal<S>
-    {
-        return VarSignal<S>(
-            std::make_shared<REACT_IMPL::VarSignalNode<S>>(
-                std::forward<V>(value)));
-    }
+    VarSignal(VarSignal<T, unique>&& other) :
+        VarSignal::VarSignalBase( std::move(other) )
+        { }
+
+    VarSignal& operator=(VarSignal<T, unique>&& other)
+        { VarSignal::SignalBase::operator=(std::move(other)); return *this; }
+
+    template <typename U, typename TGroup>
+    VarSignal(U&& value, const TGroup& group) :
+        VarSignal::VarSignalBase( CreateVarNode(std::forward<U>(value), group) )
+        { }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Flatten
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/*template <typename TInner, EOwnershipPolicy ownership_policy>
+auto Flatten(const SignalBase<SignalBase<TInner>>& outer) -> Signal<TInner, ownership_policy>
+{
+    return Signal<TInner>(
+        std::make_shared<REACT_IMPL::FlattenNode<Signal<TInner>, TInner>>(
+            GetNodePtr(outer), GetNodePtr(outer.Value())));
+}*/
+
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 template <typename L, typename R>
-bool Equals(const Signal<L>& lhs, const Signal<R>& rhs)
+bool Equals(const SignalBase<L>& lhs, const SignalBase<R>& rhs)
 {
     return lhs.Equals(rhs);
 }
diff --git a/include/react/TypeTraits.h b/include/react/TypeTraits.h
deleted file mode 100644
index 97c12654..00000000
--- a/include/react/TypeTraits.h
+++ /dev/null
@@ -1,92 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_TYPETRAITS_H_INCLUDED
-#define REACT_TYPETRAITS_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class Signal;
-
-template <typename T>
-class VarSignal;
-
-template <typename T>
-class Events;
-
-template <typename T>
-class EventSource;
-
-class Observer;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsSignal
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsSignal { static const bool value = false; };
-
-template <typename T>
-struct IsSignal<Signal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsSignal<VarSignal<T>> { static const bool value = true; };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsEvent { static const bool value = false; };
-
-template <typename T>
-struct IsEvent<Events<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsEvent<EventSource<T>> { static const bool value = true; };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsReactive
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsReactive { static const bool value = false; };
-
-template <typename T>
-struct IsReactive<Signal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsReactive<VarSignal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsReactive<Events<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsReactive<EventSource<T>> { static const bool value = true; };
-
-template <>
-struct IsReactive<Observer> { static const bool value = true; };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DecayInput
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct DecayInput { using Type = T; };
-
-template <typename T>
-struct DecayInput<VarSignal<T>> { using Type = Signal<T>; };
-
-template <typename T>
-struct DecayInput<EventSource<T>> { using Type = Events<T>; };
-
-/******************************************/ REACT_END /******************************************/
-
-#endif // REACT_TYPETRAITS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/Containers.h b/include/react/common/Containers.h
index 1839bd46..a03257db 100644
--- a/include/react/common/Containers.h
+++ b/include/react/common/Containers.h
@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <array>
+#include <iterator>
 #include <type_traits>
 #include <vector>
 
@@ -40,6 +41,153 @@ class EnumFlags
     FlagsT  flags_ = 0;
 };
 
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// IndexMap
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+class IndexMap
+{
+    static const size_t initial_capacity = 8;
+    static const size_t grow_factor = 2;
+
+public:
+    using ValueType = T;
+
+    IndexMap() = default;
+
+    IndexMap(const IndexMap&) = default;
+    IndexMap& operator=(const IndexMap&) = default;
+
+    IndexMap(IndexMap&&) = default;
+    IndexMap& operator=(IndexMap&&) = default;
+
+    T& operator[](size_t index)
+        { return data_[index]; }
+
+    const T& operator[](size_t index) const
+        { return data_[index]; }
+
+    size_t Insert(T value)
+    {
+        if (IsAtFullCapacity())
+        {
+            Grow();
+            return InsertAtBack(std::move(value));
+        }
+        else if (HasFreeIndices())
+        {
+            return InsertAtFreeIndex(std::move(value));
+        }
+        else
+        {
+            return InsertAtBack(std::move(value));
+        }
+    }
+
+    void Remove(size_t index)
+    {
+        for (size_t index : freeIndices_)
+            data_[index].~T();
+        --size_;
+        freeIndices_.push_back(index);
+    }
+
+    void Clear()
+    {
+        // Sort free indexes so we can remove check for them in linear time
+        std::sort(freeIndices_.begin(), freeIndices_.end());
+        
+        const size_t totalSize = size_ + freeIndices_.size();
+        size_t i = 0;
+
+        // Skip over free indices
+        for (auto freeIndex : freeIndices_)
+        {
+            for (; i < totalSize; ++i)
+            {
+                if (i == freeIndex)
+                    break;
+                else
+                    data_[i].~T();
+            }
+        }
+
+        // Rest
+        for (; i < totalSize; ++i)
+            data_[i].~T();
+
+        size_ = 0;
+        freeIndices_.clear();
+    }
+
+    void Reset()
+    {
+        Clear();
+
+        capacity_ = 0;
+        delete[] data_;
+
+        freeIndices_.shrink_to_fit();
+    }
+
+    ~IndexMap()
+        { Reset(); }
+
+private:
+    bool IsAtFullCapacity() const
+        { return capacity_ == size_; }
+
+    bool HasFreeIndices() const
+        { return !freeIndices_.empty(); }
+
+    size_t CalcNextCapacity() const
+        { return capacity_ == 0? initial_capacity : capacity_ * grow_factor;  }
+
+    void Grow()
+    {
+        // Allocate new storage
+        size_t  newCapacity = CalcNextCapacity();
+        T*      newData = new T[newCapacity];
+
+        // Move data to new storage
+        for (size_t i = 0; i < size_; ++i)
+        {
+            new (&newData[i]) T(std::move(data_[i]));
+            data_[i].~T();
+        }
+            
+        delete[] data_;
+
+        // Use new storage
+        data_ = newData;
+        capacity_ = newCapacity;
+    }
+
+    size_t InsertAtBack(T&& value)
+    {
+        new (&data_[size_]) T(std::move(value));
+        return size_++;
+    }
+
+    size_t InsertAtFreeIndex(T&& value)
+    {
+        size_t nextFreeIndex = freeIndices_.back();
+        freeIndices_.pop_back();
+
+        new (&data_[nextFreeIndex]) T(std::move(value));
+        ++size_;
+
+        return nextFreeIndex;
+    }
+
+    T*      data_       = nullptr;
+    size_t  size_       = 0;
+    size_t  capacity_   = 0;
+
+    std::vector<size_t> freeIndices_;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// NodeVector
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/common/TopoQueue.h b/include/react/common/TopoQueue.h
index b86885ff..091d116f 100644
--- a/include/react/common/TopoQueue.h
+++ b/include/react/common/TopoQueue.h
@@ -25,7 +25,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// TopoQueue - Sequential
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename TLevelFunc>
+
+template <typename T>
+int GetNodeLevel(const T& node)
+    { return node.level; }
+
+template <typename T>
+int GetNodeLevel(const T* node)
+    { return node->level; }
+
+template <typename T>
 class TopoQueue
 {
 private:
@@ -39,14 +48,9 @@ class TopoQueue
     TopoQueue() = default;
     TopoQueue(const TopoQueue&) = default;
 
-    template <typename FIn>
-    TopoQueue(FIn&& levelFunc) :
-        levelFunc_( std::forward<FIn>(levelFunc) )
-    {}
-
     void Push(const T& value)
     {
-        queueData_.emplace_back(value, levelFunc_(value));
+        queueData_.emplace_back(value, GetNodeLevel(value));
     }
 
     bool FetchNext()
@@ -64,7 +68,7 @@ class TopoQueue
         auto p = std::partition(
             queueData_.begin(),
             queueData_.end(),
-            LevelCompFunctor{ minLevel_ });
+            [minLevel_] (const Entry& e) { return minLevel_ != e.level; });
 
         // Reserve once to avoid multiple re-allocations
         nextData_.reserve(std::distance(p, queueData_.end()));
diff --git a/include/react/common/Util.h b/include/react/common/Util.h
index 19fe74f4..741cd61d 100644
--- a/include/react/common/Util.h
+++ b/include/react/common/Util.h
@@ -17,6 +17,12 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
+template <typename ... Ts>
+struct MakeVoid { using type = void;};
+
+template <typename ... Ts>
+using VoidType = typename MakeVoid<Ts ...>::type;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Unpack tuple - see
 /// http://stackoverflow.com/questions/687490/how-do-i-expand-a-tuple-into-variadic-template-functions-arguments
@@ -25,8 +31,7 @@
 template<size_t N>
 struct Apply {
     template<typename F, typename T, typename... A>
-    static inline auto apply(F && f, T && t, A &&... a)
-        -> decltype(Apply<N-1>::apply(std::forward<F>(f), std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...))
+    static auto apply(F&& f, T&& t, A&&... a) -> decltype(auto)
     {
         return Apply<N-1>::apply(std::forward<F>(f), std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
     }
@@ -36,26 +41,22 @@ template<>
 struct Apply<0>
 {
     template<typename F, typename T, typename... A>
-    static inline auto apply(F && f, T &&, A &&... a)
-        -> decltype(std::forward<F>(f)(std::forward<A>(a)...))
+    static auto apply(F&& f, T&&, A&&... a) -> decltype(auto)
     {
         return std::forward<F>(f)(std::forward<A>(a)...);
     }
 };
 
 template<typename F, typename T>
-inline auto apply(F && f, T && t)
-    -> decltype(Apply<std::tuple_size<typename std::decay<T>::type>::value>::apply(std::forward<F>(f), std::forward<T>(t)))
+inline auto apply(F&& f, T&& t) -> decltype(auto)
 {
-    return Apply<std::tuple_size<typename std::decay<T>::type>::value>
-        ::apply(std::forward<F>(f), std::forward<T>(t));
+    return Apply<std::tuple_size<typename std::decay<T>::type>::value>::apply(std::forward<F>(f), std::forward<T>(t));
 }
 
 template<size_t N>
 struct ApplyMemberFn {
     template <typename O, typename F, typename T, typename... A>
-    static inline auto apply(O obj, F f, T && t, A &&... a)
-        -> decltype(ApplyMemberFn<N-1>::apply(obj, f, std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...))
+    static inline auto apply(O obj, F f, T && t, A &&... a) -> decltype(auto)
     {
         return ApplyMemberFn<N-1>::apply(obj, f, std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
     }
@@ -194,12 +195,7 @@ struct AddDefaultReturnValueWrapper
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IsCallableWith
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename F,
-    typename TRet,
-    typename ... TArgs
->
+template <typename F, typename TRet, typename ... TArgs>
 class IsCallableWith
 {
 private:
@@ -209,9 +205,7 @@ class IsCallableWith
     template
     <
         typename U,
-        class = decltype(
-            static_cast<TRet>(
-                (std::declval<U>())(std::declval<TArgs>() ...)))
+        typename = decltype(static_cast<TRet>((std::declval<U>())(std::declval<TArgs>() ...)))
     >
     static YesT& check(void*);
 
@@ -219,7 +213,7 @@ class IsCallableWith
     static NoT& check(...);
 
 public:
-    enum { value = sizeof(check<F>(nullptr)) == sizeof(YesT) };
+    static const bool value = sizeof(check<F>(nullptr)) == sizeof(YesT);
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
@@ -228,4 +222,22 @@ class IsCallableWith
 // Use comma operator to replace potential void return value with 0
 #define REACT_EXPAND_PACK(...) REACT_IMPL::pass((__VA_ARGS__ , 0) ...)
 
+#define REACT_DEFINE_BITMASK_OPERATORS(t) \
+    inline t operator|(t lhs, t rhs) \
+        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t operator&(t lhs, t rhs) \
+        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) & static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t operator^(t lhs, t rhs) \
+        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t operator~(t rhs) \
+        { return static_cast<t>(~static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t& operator|=(t& lhs, t rhs) \
+        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); return lhs; } \
+    inline t& operator&=(t& lhs, t rhs) \
+        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) & static_cast<std::underlying_type<t>::type>(rhs)); return lhs; } \
+    inline t& operator^=(t& lhs, t rhs) \
+        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); return lhs; }
+
+// Bitmask helper
+
 #endif // REACT_COMMON_UTIL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/Defs.h b/include/react/detail/Defs.h
index 5dd2f91f..24f4cd97 100644
--- a/include/react/detail/Defs.h
+++ b/include/react/detail/Defs.h
@@ -21,23 +21,10 @@
 #define REACT_IMPL_END      REACT_END       }
 #define REACT_IMPL          REACT           ::impl
 
-#ifdef _DEBUG
-#define REACT_MESSAGE(...) printf(__VA_ARGS__)
-#else
-#define REACT_MESSAGE
-#endif
-
 // Assert with message
 #define REACT_ASSERT(condition, ...) for (; !(condition); assert(condition)) printf(__VA_ARGS__)
 #define REACT_ERROR(...)    REACT_ASSERT(false, __VA_ARGS__)
 
-// Logging
-#ifdef REACT_ENABLE_LOGGING
-    #define REACT_LOG(...) __VA_ARGS__
-#else
-    #define REACT_LOG(...)
-#endif
-
 // Thread local storage
 #if _WIN32 || _WIN64
     // MSVC
diff --git a/include/react/detail/DomainBase.h b/include/react/detail/DomainBase.h
deleted file mode 100644
index 7327874b..00000000
--- a/include/react/detail/DomainBase.h
+++ /dev/null
@@ -1,265 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_DOMAINBASE_H_INCLUDED
-#define REACT_DETAIL_DOMAINBASE_H_INCLUDED
-
-#pragma once
-
-#include <memory>
-#include <utility>
-
-#include "react/detail/Defs.h"
-
-#include "react/detail/ReactiveBase.h"
-#include "react/detail/IReactiveEngine.h"
-#include "react/detail/graph/ContinuationNodes.h"
-
-// Include all engines for convenience
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/SubtreeEngine.h"
-#include "react/engine/ToposortEngine.h"
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
-class Signal;
-
-template <typename D, typename S>
-class VarSignal;
-
-template <typename D, typename E>
-class Events;
-
-template <typename D, typename E>
-class EventSource;
-
-enum class Token;
-
-template <typename D>
-class Observer;
-
-template <typename D>
-class ScopedObserver;
-
-template <typename D>
-class Reactor;
-
-/******************************************/ REACT_END /******************************************/
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Common types & constants
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-// Domain modes
-enum EDomainMode
-{
-    sequential,
-    sequential_concurrent,
-    parallel,
-    parallel_concurrent
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DomainBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename TPolicy>
-class DomainBase
-{
-public:
-    using TurnT = typename TPolicy::Engine::TurnT;
-
-    DomainBase() = delete;
-
-    using Policy = TPolicy;
-    using Engine = REACT_IMPL::EngineInterface<D, typename Policy::Engine>;
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    /// Domain traits
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    static const bool uses_node_update_timer =
-        REACT_IMPL::NodeUpdateTimerEnabled<typename Policy::Engine>::value;
-
-    static const bool is_concurrent =
-        Policy::input_mode == REACT_IMPL::concurrent_input;
-
-    static const bool is_parallel =
-        Policy::propagation_mode == REACT_IMPL::parallel_propagation;
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    /// Aliases for reactives of this domain
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    template <typename S>
-    using SignalT = Signal<D,S>;
-
-    template <typename S>
-    using VarSignalT = VarSignal<D,S>;
-
-    template <typename E = Token>
-    using EventsT = Events<D,E>;
-
-    template <typename E = Token>
-    using EventSourceT = EventSource<D,E>;
-
-    using ObserverT = Observer<D>;
-
-    using ScopedObserverT = ScopedObserver<D>;
-
-    using ReactorT = Reactor<D>;
-
-#ifdef REACT_ENABLE_LOGGING
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    /// Log
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    static EventLog& Log()
-    {
-        static EventLog instance;
-        return instance;
-    }
-#endif //REACT_ENABLE_LOGGING
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ContinuationBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename D2
->
-class ContinuationBase : public MovableReactive<NodeBase<D>>
-{
-public:
-    ContinuationBase() = default;
-
-    template <typename T>
-    ContinuationBase(T&& t) :
-        ContinuationBase::MovableReactive( std::forward<T>(t) )
-    {}
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ModeSelector - Translate domain mode to individual propagation and input modes
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-template <EDomainMode>
-struct ModeSelector;
-
-template <>
-struct ModeSelector<sequential>
-{
-    static const EInputMode         input       = consecutive_input;
-    static const EPropagationMode   propagation = sequential_propagation;
-};
-
-template <>
-struct ModeSelector<sequential_concurrent>
-{
-    static const EInputMode         input       = concurrent_input;
-    static const EPropagationMode   propagation = sequential_propagation;
-};
-
-template <>
-struct ModeSelector<parallel>
-{
-    static const EInputMode         input       = consecutive_input;
-    static const EPropagationMode   propagation = parallel_propagation;
-};
-
-template <>
-struct ModeSelector<parallel_concurrent>
-{
-    static const EInputMode         input       = concurrent_input;
-    static const EPropagationMode   propagation = parallel_propagation;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// GetDefaultEngine - Get default engine type for given propagation mode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <EPropagationMode>
-struct GetDefaultEngine;
-
-template <>
-struct GetDefaultEngine<sequential_propagation>
-{
-    using Type = ToposortEngine<sequential_propagation>;
-};
-
-template <>
-struct GetDefaultEngine<parallel_propagation>
-{
-    using Type = SubtreeEngine<parallel_propagation>;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EngineTypeBuilder - Instantiate the given template engine type with mode.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <EPropagationMode>
-struct DefaultEnginePlaceholder;
-
-// Concrete engine template type
-template
-<
-    EPropagationMode mode,
-    template <EPropagationMode> class TTEngine
->
-struct EngineTypeBuilder
-{
-    using Type = TTEngine<mode>;
-};
-
-// Placeholder engine type - use default engine for given mode
-template
-<
-    EPropagationMode mode
->
-struct EngineTypeBuilder<mode,DefaultEnginePlaceholder>
-{
-    using Type = typename GetDefaultEngine<mode>::Type;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DomainPolicy
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    EDomainMode mode,
-    template <EPropagationMode> class TTEngine = DefaultEnginePlaceholder
->
-struct DomainPolicy
-{
-    static const EInputMode         input_mode          = ModeSelector<mode>::input;
-    static const EPropagationMode   propagation_mode    = ModeSelector<mode>::propagation;
-
-    using Engine = typename EngineTypeBuilder<propagation_mode,TTEngine>::Type;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Ensure singletons are created immediately after domain declaration (TODO hax)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class DomainInitializer
-{
-public:
-    DomainInitializer()
-    {
-#ifdef REACT_ENABLE_LOGGING
-        D::Log();
-#endif //REACT_ENABLE_LOGGING
-
-        D::Engine::Instance();
-        DomainSpecificInputManager<D>::Instance();
-    }
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_DOMAINBASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/EventBase.h b/include/react/detail/EventBase.h
deleted file mode 100644
index bf518860..00000000
--- a/include/react/detail/EventBase.h
+++ /dev/null
@@ -1,49 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_EVENTBASE_H_INCLUDED
-#define REACT_DETAIL_EVENTBASE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <utility>
-
-#include "react/detail/ReactiveBase.h"
-#include "react/detail/ReactiveInput.h"
-#include "react/detail/graph/EventNodes.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventStreamBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class EventStreamBase : public ReactiveBase<EventStreamNode<E>>
-{
-public:
-    EventStreamBase() = default;
-    EventStreamBase(const EventStreamBase&) = default;
-
-    template <typename T>
-    EventStreamBase(T&& t) :
-        EventStreamBase::CopyableReactive( std::forward<T>(t) )
-    {}
-
-protected:
-    template <typename T>
-    void emit(T&& e) const
-    {
-        DomainSpecificInputManager<D>::Instance().AddInput(
-            *reinterpret_cast<EventSourceNode<D,E>*>(this->ptr_.get()),
-            std::forward<T>(e));
-    }
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_EVENTBASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/IReactiveGraph.h
new file mode 100644
index 00000000..ddb29689
--- /dev/null
+++ b/include/react/detail/IReactiveGraph.h
@@ -0,0 +1,100 @@
+
+//          Copyright Sebastian Jeckel 2016.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
+#define REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/Defs.h"
+
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include "react/API.h"
+#include "react/common/Types.h"
+#include "react/common/Util.h"
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Definitions
+///////////////////////////////////////////////////////////////////////////////////////////////////
+using NodeId = size_t;
+using TurnId = size_t;
+
+static NodeId invalid_node_id = (std::numeric_limits<size_t>::max)();
+static TurnId invalid_turn_id = (std::numeric_limits<size_t>::max)();
+
+enum class UpdateResult
+{
+    unchanged,
+    changed,
+    shifted
+};
+
+struct IReactiveGraph;
+struct IReactiveNode;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// IReactiveGraph
+///////////////////////////////////////////////////////////////////////////////////////////////////
+struct IReactiveGraph
+{
+    virtual ~IReactiveGraph() = default;
+
+    virtual NodeId RegisterNode(IReactiveNode* nodePtr) = 0;
+    virtual void UnregisterNode(NodeId node) = 0;
+
+    virtual void OnNodeAttach(NodeId nodeId, NodeId parentId) = 0;
+    virtual void OnNodeDetach(NodeId nodeId, NodeId parentId) = 0;
+
+    virtual void OnDynamicNodeAttach(NodeId nodeId, NodeId parentId, TurnId turn) = 0;
+    virtual void OnDynamicNodeDetach(NodeId nodeId, NodeId parentId, TurnId turn) = 0;
+
+    virtual void AddInput(NodeId nodeId, std::function<void()> inputCallback) = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// IReactiveNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+struct IReactiveNode
+{
+    virtual ~IReactiveNode() = default;
+
+    /// Returns unique type identifier
+    virtual const char* GetNodeType() const = 0;
+
+    // Note: Could get rid of this ugly ptr by adding a template parameter to the interface
+    // But that would mean all engine nodes need that template parameter too - so rather cast
+    virtual UpdateResult Update(TurnId turnId) = 0;  
+
+    /// Input nodes can be manipulated externally.
+    virtual bool IsInputNode() const = 0;
+
+    /// Output nodes can't have any successors.
+    virtual bool IsOutputNode() const = 0;
+
+    /// Dynamic nodes may change in topology as a result of tick.
+    virtual bool IsDynamicNode() const = 0;
+
+    // Number of predecessors.
+    virtual int GetDependencyCount() const = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EPropagationMode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+enum EPropagationMode
+{
+    sequential_propagation,
+    parallel_propagation
+};
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
+#endif // REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/IReactiveGroup.h b/include/react/detail/IReactiveGroup.h
deleted file mode 100644
index b86a389c..00000000
--- a/include/react/detail/IReactiveGroup.h
+++ /dev/null
@@ -1,64 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
-#define REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
-
-#pragma once
-
-#include <memory>
-#include <utility>
-
-#include "react/detail/Defs.h"
-#include "react/common/Types.h"
-#include "react/logging/EventRecords.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-using NodeId = uint;
-using TurnId = uint;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IReactiveEngine
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IReactiveGroup
-{
-    virtual ~IReactiveGroup() = 0;
-
-    virtual void OnTurnAdmissionStart(TurnId turn) = 0;
-    virtual void OnTurnAdmissionEnd(TurnId turn) = 0;
-
-    virtual void OnInputChange(NodeId node, TurnId turn) = 0;
-
-    virtual void Propagate(TurnId turn) = 0;
-
-    virtual NodeId OnNodeCreate() = 0;
-    virtual void OnNodeDestroy(NodeId node) = 0;
-
-    virtual void OnNodeAttach(NodeId node, NodeId parent) = 0;
-    virtual void OnNodeDetach(NodeId node, NodeId parent) = 0;
-
-    virtual void OnDynamicNodeAttach(NodeId node, NodeId parent, TurnId turn) = 0;
-    virtual void OnDynamicNodeDetach(NodeId node, NodeId parent, TurnId turn) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Engine traits
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename> struct NodeUpdateTimerEnabled : std::false_type {};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EPropagationMode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum EPropagationMode
-{
-    sequential_propagation,
-    parallel_propagation
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/IReactiveNode.h b/include/react/detail/IReactiveNode.h
deleted file mode 100644
index 68fe08be..00000000
--- a/include/react/detail/IReactiveNode.h
+++ /dev/null
@@ -1,67 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_IREACTIVENODE_H_INCLUDED
-#define REACT_DETAIL_IREACTIVENODE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-enum class UpdateResult
-{
-    unchanged,
-    changed,
-    shifted
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IReactiveNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IReactiveNode
-{
-    virtual ~IReactiveNode() = default;
-
-    /// Returns unique type identifier
-    virtual const char* GetNodeType() const = 0;
-
-    // Note: Could get rid of this ugly ptr by adding a template parameter to the interface
-    // But that would mean all engine nodes need that template parameter too - so rather cast
-    virtual UpdateResult Update() = 0;  
-
-    /// Input nodes can be manipulated externally.
-    virtual bool IsInputNode() const = 0;
-
-    /// Output nodes can't have any successors.
-    virtual bool IsOutputNode() const = 0;
-
-    /// Dynamic nodes may change in topology as a result of tick.
-    virtual bool IsDynamicNode() const = 0;
-
-    // Number of predecessors.
-    // This information is statically available at compile time on the graph layer,
-    // so the engine does not have to calculate it again.
-    virtual int DependencyCount() const = 0;
-
-    // Heavyweight nodes are worth parallelizing.
-    virtual bool IsHeavyweight() const = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IInputNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IInputNode
-{
-    virtual ~IInputNode() = default;
-
-    virtual bool ApplyInput(void* turnPtr) = 0;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif //REACT_DETAIL_IREACTIVENODE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/ReactiveBase.h b/include/react/detail/ReactiveBase.h
deleted file mode 100644
index 12dafd82..00000000
--- a/include/react/detail/ReactiveBase.h
+++ /dev/null
@@ -1,158 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_REACTIVEBASE_H_INCLUDED
-#define REACT_DETAIL_REACTIVEBASE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <memory>
-#include <utility>
-
-#include "react/detail/graph/GraphBase.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <typename L, typename R>
-bool Equals(const L& lhs, const R& rhs)
-{
-    return lhs == rhs;
-}
-
-template <typename L, typename R>
-bool Equals(const std::reference_wrapper<L>& lhs, const std::reference_wrapper<R>& rhs)
-{
-    return lhs.get() == rhs.get();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ReactiveBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode>
-class ReactiveBase
-{
-public:
-    using DomainT   = typename TNode::DomainT;
-    
-    // Default ctor
-    ReactiveBase() = default;
-
-    // Copy ctor
-    ReactiveBase(const ReactiveBase&) = default;
-
-    // Move ctor (VS2013 doesn't default generate that yet)
-    ReactiveBase(ReactiveBase&& other) :
-        ptr_( std::move(other.ptr_) )
-    {}
-
-    // Explicit node ctor
-    explicit ReactiveBase(std::shared_ptr<TNode>&& ptr) :
-        ptr_( std::move(ptr) )
-    {}
-
-    // Copy assignment
-    ReactiveBase& operator=(const ReactiveBase&) = default;
-
-    // Move assignment
-    ReactiveBase& operator=(ReactiveBase&& other)
-    {
-        ptr_.reset(std::move(other));
-        return *this;
-    }
-
-    bool IsValid() const
-    {
-        return ptr_ != nullptr;
-    }
-
-    void SetWeightHint(WeightHint weight)
-    {
-        assert(IsValid());
-        ptr_->SetWeightHint(weight);
-    }
-
-protected:
-    std::shared_ptr<TNode>  ptr_;
-
-    template <typename TNode_>
-    friend const std::shared_ptr<TNode_>& GetNodePtr(const ReactiveBase<TNode_>& node);
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// CopyableReactive
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode>
-class CopyableReactive : public ReactiveBase<TNode>
-{
-public:
-    CopyableReactive() = default;
-
-    CopyableReactive(const CopyableReactive&) = default;
-
-    CopyableReactive(CopyableReactive&& other) :
-        CopyableReactive::ReactiveBase( std::move(other) )
-    {}
-
-    explicit CopyableReactive(std::shared_ptr<TNode>&& ptr) :
-        CopyableReactive::ReactiveBase( std::move(ptr) )
-    {}
-
-    CopyableReactive& operator=(const CopyableReactive&) = default;
-
-    CopyableReactive& operator=(CopyableReactive&& other)
-    {
-        CopyableReactive::ReactiveBase::operator=(std::move(other));
-        return *this;
-    }
-
-    bool Equals(const CopyableReactive& other) const
-    {
-        return this->ptr_ == other.ptr_;
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// UniqueReactiveBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode>
-class MovableReactive : public ReactiveBase<TNode>
-{
-public:
-    MovableReactive() = default;
-
-    MovableReactive(MovableReactive&& other) :
-        MovableReactive::ReactiveBase( std::move(other) )
-    {}
-
-    explicit MovableReactive(std::shared_ptr<TNode>&& ptr) :
-        MovableReactive::ReactiveBase( std::move(ptr) )
-    {}
-
-    MovableReactive& operator=(MovableReactive&& other)
-    {
-        MovableReactive::ReactiveBase::operator=(std::move(other));
-        return *this;
-    }
-
-    // Deleted copy ctor and assignment
-    MovableReactive(const MovableReactive&) = delete;
-    MovableReactive& operator=(const MovableReactive&) = delete;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// GetNodePtr
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode>
-const std::shared_ptr<TNode>& GetNodePtr(const ReactiveBase<TNode>& node)
-{
-    return node.ptr_;
-}
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_REACTIVEBASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/ReactiveInput.h b/include/react/detail/ReactiveInput.h
index ffcbcd6b..dd2d101c 100644
--- a/include/react/detail/ReactiveInput.h
+++ b/include/react/detail/ReactiveInput.h
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #ifndef REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
 #define REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
 
@@ -36,17 +38,11 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IInputNode;
 class IObserver;
 
-template <typename D>
-class InputManager;
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Common types & constants
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-using TurnIdT = uint;
-using TransactionFuncT = std::function<void()>;
 
 enum ETransactionFlags
 {
@@ -985,4 +981,6 @@ class DomainSpecificInputManager
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
+
+#endif
\ No newline at end of file
diff --git a/include/react/detail/SignalBase.h b/include/react/detail/SignalBase.h
deleted file mode 100644
index 9b497136..00000000
--- a/include/react/detail/SignalBase.h
+++ /dev/null
@@ -1,65 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_SIGNALBASE_H_INCLUDED
-#define REACT_DETAIL_SIGNALBASE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <utility>
-
-#include "react/detail/ReactiveBase.h"
-#include "react/detail/ReactiveInput.h"
-#include "react/detail/graph/SignalNodes.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
-class SignalBase : public CopyableReactive<SignalNode<D,S>>
-{
-public:
-    SignalBase() = default;
-    SignalBase(const SignalBase&) = default;
-    
-    template <typename T>
-    SignalBase(T&& t) :
-        SignalBase::CopyableReactive( std::forward<T>(t) )
-    {}
-
-protected:
-    const S& getValue() const
-    {
-        return this->ptr_->ValueRef();
-    }
-
-    template <typename T>
-    void setValue(T&& newValue) const
-    {
-        DomainSpecificInputManager<D>::Instance().AddInput(
-            *reinterpret_cast<VarNode<D,S>*>(this->ptr_.get()),
-            std::forward<T>(newValue));
-    }
-
-    template <typename F>
-    void modifyValue(const F& func) const
-    {
-        DomainSpecificInputManager<D>::Instance().ModifyInput(
-            *reinterpret_cast<VarNode<D,S>*>(this->ptr_.get()), func);
-    }
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_SIGNALBASE_H_INCLUDED
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index eb158c4b..4c4fdc35 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -81,578 +81,419 @@ struct AddIterateByRefRangeWrapper
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E,
-    typename TFunc
->
-class IterateNode :
-    public SignalNode<D,S>
+template <typename S, typename E, typename F>
+class IterateNode : public SignalNode<S>
 {
-    using Engine = typename IterateNode::Engine;
-
 public:
-    template <typename T, typename F>
-    IterateNode(T&& init, const std::shared_ptr<EventStreamNode<D,E>>& events, F&& func) :
-        IterateNode::SignalNode( std::forward<T>(init) ),
+    template <typename U, typename V>
+    IterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& init, const std::shared_ptr<EventStreamNode<E>>& events, V&& func) :
+        IterateNode::SignalNode( graphPtr, std::forward<U>(init) ),
         events_( events ),
-        func_( std::forward<F>(func) )
+        func_( std::forward<V>(func) )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *events);
+        this->RegisterMe();
+        this->AttachToMe(events->GetNodeId());
     }
 
     ~IterateNode()
     {
-        Engine::OnNodeDetach(*this, *events_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(events_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        bool changed = false;
-
-        {// timer
-            using TimerT = typename IterateNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, events_->Events().size() );
-
-            S newValue = func_(EventRange<E>( events_->Events() ), this->value_);
-
-            if (! Equals(newValue, this->value_))
-            {
-                this->value_ = std::move(newValue);
-                changed = true;
-            }
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+        S newValue = func_(EventRange<E>( events_->Events() ), this->Value());
 
-        if (changed)
-            Engine::OnNodePulse(*this, turn);
+        if (! Equals(newValue, this->Value()))
+        {
+            this->Value() = std::move(newValue);
+            return UpdateResult::changed;
+        }
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+        {
+            return UpdateResult::unchanged;
+        }
     }
 
-    virtual const char* GetNodeType() const override        { return "IterateNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
+    virtual const char* GetNodeType() const override
+        { return "Iterate"; }
+
+    virtual int GetDependencyCount() const override
+        { return 1; }
 
 private:
-    std::shared_ptr<EventStreamNode<D,E>> events_;
+    std::shared_ptr<EventStreamNode<E>> events_;
     
-    TFunc   func_;
+    F   func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IterateByRefNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E,
-    typename TFunc
->
-class IterateByRefNode :
-    public SignalNode<D,S>
+template <typename S, typename E, typename F>
+class IterateByRefNode : public SignalNode<S>
 {
-    using Engine = typename IterateByRefNode::Engine;
-
 public:
-    template <typename T, typename F>
-    IterateByRefNode(T&& init, const std::shared_ptr<EventStreamNode<D,E>>& events, F&& func) :
-        IterateByRefNode::SignalNode( std::forward<T>(init) ),
-        func_( std::forward<F>(func) ),
+    template <typename SIn, typename FIn>
+    IterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, SIn&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func) :
+        IterateByRefNode::SignalNode( graphPtr, std::forward<SIn>(init) ),
+        func_( std::forward<FIn>(func) ),
         events_( events )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *events);
+        this->RegisterMe();
+        this->AttachToMe(events->GetNodeId());
     }
 
     ~IterateByRefNode()
     {
-        Engine::OnNodeDetach(*this, *events_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(events_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        {// timer
-            using TimerT = typename IterateByRefNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, events_->Events().size() );
-
-            func_(EventRange<E>( events_->Events() ), this->value_);
-
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+        func_(EventRange<E>( events_->Events() ), this->Value());
 
         // Always assume change
-        Engine::OnNodePulse(*this, turn);
+        return UpdateResult::changed;
     }
 
-    virtual const char* GetNodeType() const override        { return "IterateByRefNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
+    virtual const char* GetNodeType() const override
+        { return "IterateByRefNode"; }
+
+    virtual int GetDependencyCount() const override
+        { return 1; }
 
 protected:
-    TFunc   func_;
+    F   func_;
 
-    std::shared_ptr<EventStreamNode<D,E>> events_;
+    std::shared_ptr<EventStreamNode<E>> events_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedIterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedIterateNode :
-    public SignalNode<D,S>
+template <typename S, typename E, typename F, typename ... TSyncs>
+class SyncedIterateNode : public SignalNode<S>
 {
-    using Engine = typename SyncedIterateNode::Engine;
-
 public:
-    template <typename T, typename F>
-    SyncedIterateNode(T&& init, const std::shared_ptr<EventStreamNode<D,E>>& events, F&& func,
-                      const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedIterateNode::SignalNode( std::forward<T>(init) ),
+    template <typename SIn, typename FIn>
+    SyncedIterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, SIn&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedIterateNode::SignalNode( graphPtr, std::forward<SIn>(init) ),
         events_( events ),
-        func_( std::forward<F>(func) ),
-        deps_( deps ... )
+        func_( std::forward<FIn>(func) ),
+        syncHolder_( syncs ... )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *events);
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedIterateNode()
     {
-        Engine::OnNodeDetach(*this, *events_);
-
-        apply(
-            DetachFunctor<D,SyncedIterateNode,
-                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-            deps_);
-
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
         events_->SetCurrentTurn(turn);
 
-        bool changed = false;
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (! events_->Events().empty())
-        {// timer
-            using TimerT = typename SyncedIterateNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, events_->Events().size() );
-            
-            S newValue = apply(
-                [this] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-                {
-                    return func_(EventRange<E>( events_->Events() ), this->value_, args->ValueRef() ...);
-                },
-                deps_);
-
-            if (! Equals(newValue, this->value_))
+        S newValue = apply(
+            [this] (const auto& ... syncs)
             {
-                changed = true;
-                this->value_ = std::move(newValue);
-            }            
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+                return func_(EventRange<E>( events_->Events() ), this->Value(), syncs->Value() ...);
+            },
+            syncHolder_);
 
-        if (changed)   
-            Engine::OnNodePulse(*this, turn);
+        if (! Equals(newValue, this->Value()))
+        {
+            this->Value() = std::move(newValue);
+            return UpdateResult::changed;
+        }
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+        {
+            return UpdateResult::unchanged;
+        }   
     }
 
-    virtual const char* GetNodeType() const override        { return "SyncedIterateNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+    virtual const char* GetNodeType() const override
+        { return "SyncedIterate"; }
 
-private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
+    virtual int GetDependencyCount() const override
+        { return 1 + sizeof...(TSyncs); }
 
-    std::shared_ptr<EventStreamNode<D,E>> events_;
+private:
+    std::shared_ptr<EventStreamNode<E>> events_;
     
-    TFunc       func_;
-    DepHolderT  deps_;
+    F func_;
+
+    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedIterateByRefNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedIterateByRefNode :
-    public SignalNode<D,S>
+template <typename S, typename E, typename TFunc, typename ... TSyncs>
+class SyncedIterateByRefNode : public SignalNode<S>
 {
-    using Engine = typename SyncedIterateByRefNode::Engine;
-
 public:
-    template <typename T, typename F>
-    SyncedIterateByRefNode(T&& init, const std::shared_ptr<EventStreamNode<D,E>>& events, F&& func,
-                           const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedIterateByRefNode::SignalNode( std::forward<T>(init) ),
+    template <typename SIn, typename FIn>
+    SyncedIterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, SIn&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedIterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
         events_( events ),
-        func_( std::forward<F>(func) ),
-        deps_( deps ... )
+        func_( std::forward<FIn>(func) ),
+        syncHolder_( syncs ... )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *events);
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+        this->RegisterMe();
+        this->AttachToMe(dep->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedIterateByRefNode()
     {
-        Engine::OnNodeDetach(*this, *events_);
-
-        apply(
-            DetachFunctor<D,SyncedIterateByRefNode,
-                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-            deps_);
-
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(dep_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
         events_->SetCurrentTurn(turn);
 
         bool changed = false;
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
         if (! events_->Events().empty())
-        {// timer
-            using TimerT = typename SyncedIterateByRefNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, events_->Events().size() );
-
+        {
             apply(
-                [this] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
+                [this] (const auto& ... args)
                 {
-                    func_(EventRange<E>( events_->Events() ), this->value_, args->ValueRef() ...);
+                    func_(EventRange<E>( events_->Events() ), this->Value(), args->Value() ...);
                 },
                 deps_);
 
-            changed = true;
-        }// ~timer
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (changed)
-            Engine::OnNodePulse(*this, turn);
+            return UpdateResult::changed;
+        }
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+        {
+            return UpdateResult::unchanged;
+        }
     }
 
-    virtual const char* GetNodeType() const override        { return "SyncedIterateByRefNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+    virtual const char* GetNodeType() const override
+        { return "SyncedIterateByRef"; }
 
-private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
+    virtual int GetDependencyCount() const override
+        { return 1 + sizeof...(TSyncs); }
 
-    std::shared_ptr<EventStreamNode<D,E>> events_;
+private:
+    std::shared_ptr<EventStreamNode<E>> events_;
     
-    TFunc       func_;
-    DepHolderT  deps_;
+    F func_;
+
+    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// HoldNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S
->
-class HoldNode : public SignalNode<D,S>
+template <typename T>
+class HoldNode : public SignalNode<T>
 {
-    using Engine = typename HoldNode::Engine;
-
 public:
-    template <typename T>
-    HoldNode(T&& init, const std::shared_ptr<EventStreamNode<D,S>>& events) :
-        HoldNode::SignalNode( std::forward<T>(init) ),
+    template <typename TIn>
+    HoldNode(const std::shared_ptr<IReactiveGraph>& graphPtr, TIn&& init, const std::shared_ptr<EventStreamNode<T>>& events) :
+        HoldNode::SignalNode( graphPtr, std::forward<TIn>(init) ),
         events_( events )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *events_);
+        this->RegisterMe();
+        this->AttachToMe(events->GetNodeId());
     }
 
     ~HoldNode()
     {
-        Engine::OnNodeDetach(*this, *events_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(events_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override    { return "HoldNode"; }
+    virtual const char* GetNodeType() const override
+        { return "HoldNode"; }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
         bool changed = false;
 
         if (! events_->Events().empty())
         {
             const S& newValue = events_->Events().back();
 
-            if (! Equals(newValue, this->value_))
+            if (! Equals(newValue, this->Value()))
             {
                 changed = true;
-                this->value_ = newValue;
+                this->Value() = newValue;
             }
         }
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
         if (changed)
-            Engine::OnNodePulse(*this, turn);
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual int     DependencyCount() const override    { return 1; }
+    virtual int GetDependencyCount() const override
+        { return 1; }
 
 private:
-    const std::shared_ptr<EventStreamNode<D,S>>    events_;
+    const std::shared_ptr<EventStreamNode<S>>    events_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SnapshotNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E
->
-class SnapshotNode : public SignalNode<D,S>
+template <typename S, typename E>
+class SnapshotNode : public SignalNode<S>
 {
-    using Engine = typename SnapshotNode::Engine;
-
 public:
-    SnapshotNode(const std::shared_ptr<SignalNode<D,S>>& target,
-                 const std::shared_ptr<EventStreamNode<D,E>>& trigger) :
-        SnapshotNode::SignalNode( target->ValueRef() ),
+    SnapshotNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
+        SnapshotNode::SignalNode( graphPtr, target->Value() ),
         target_( target ),
         trigger_( trigger )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *target_);
-        Engine::OnNodeAttach(*this, *trigger_);
+        this->RegisterMe();
+        this->AttachToMe(target->GetNodeId());
+        this->AttachToMe(trigger->GetNodeId());
     }
 
     ~SnapshotNode()
     {
-        Engine::OnNodeDetach(*this, *target_);
-        Engine::OnNodeDetach(*this, *trigger_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(trigger_->GetNodeId());
+        this->DetachFromMe(target_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        trigger_->SetCurrentTurn(turn);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
+        trigger_->SetCurrentTurn(turnId);
 
         bool changed = false;
         
         if (! trigger_->Events().empty())
         {
-            const S& newValue = target_->ValueRef();
+            const S& newValue = target_->Value();
 
-            if (! Equals(newValue, this->value_))
+            if (! Equals(newValue, this->Value()))
             {
                 changed = true;
-                this->value_ = newValue;
+                this->Value() = newValue;
             }
         }
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
         if (changed)
-            Engine::OnNodePulse(*this, turn);
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "SnapshotNode"; }
-    virtual int         DependencyCount() const override    { return 2; }
+    virtual const char* GetNodeType() const override
+        { return "Snapshot"; }
+
+    virtual int GetDependencyCount() const override
+        { return 2; }
 
 private:
-    const std::shared_ptr<SignalNode<D,S>>      target_;
-    const std::shared_ptr<EventStreamNode<D,E>> trigger_;
+    std::shared_ptr<SignalNode<S>>      target_;
+    std::shared_ptr<EventStreamNode<E>> trigger_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// MonitorNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E
->
-class MonitorNode : public EventStreamNode<D,E>
+template <typename T>
+class MonitorNode : public EventStreamNode<T>
 {
-    using Engine = typename MonitorNode::Engine;
-
 public:
-    MonitorNode(const std::shared_ptr<SignalNode<D,E>>& target) :
-        MonitorNode::EventStreamNode( ),
+    MonitorNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<T>>& target) :
+        MonitorNode::EventStreamNode( graphPtr ),
         target_( target )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *target_);
+        this->RegisterMe();
+        this->AttachToMe(target->GetNodeId());
     }
 
     ~MonitorNode()
     {
-        Engine::OnNodeDetach(*this, *target_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(target_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
         this->SetCurrentTurn(turn, true);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        this->events_.push_back(target_->ValueRef());
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
+        this->Events().push_back(target_->Value());
 
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
-        else
-            Engine::OnNodeIdlePulse(*this, turn);
+        return UpdateResult::changed;
     }
 
-    virtual const char* GetNodeType() const override        { return "MonitorNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
+    virtual const char* GetNodeType() const override
+        { return "Monitor"; }
+
+    virtual int GetDependencyCount() const override
+        { return 1; }
 
 private:
-    const std::shared_ptr<SignalNode<D,E>>    target_;
+    std::shared_ptr<SignalNode<E>>    target_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// PulseNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename E
->
-class PulseNode : public EventStreamNode<D,S>
+template <typename S, typename E>
+class PulseNode : public EventStreamNode<S>
 {
-    using Engine = typename PulseNode::Engine;
-
 public:
-    PulseNode(const std::shared_ptr<SignalNode<D,S>>& target,
-              const std::shared_ptr<EventStreamNode<D,E>>& trigger) :
-        PulseNode::EventStreamNode( ),
+    PulseNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
+        PulseNode::EventStreamNode( graphPtr ),
         target_( target ),
         trigger_( trigger )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *target_);
-        Engine::OnNodeAttach(*this, *trigger_);
+        this->RegisterMe();
+        this->AttachToMe(target->GetNodeId());
+        this->AttachToMe(trigger->GetNodeId());
     }
 
     ~PulseNode()
     {
-        Engine::OnNodeDetach(*this, *target_);
-        Engine::OnNodeDetach(*this, *trigger_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(trigger_->GetNodeId());
+        this->DetachFromMe(target_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        typedef typename D::Engine::TurnT TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
         this->SetCurrentTurn(turn, true);
         trigger_->SetCurrentTurn(turn);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        for (uint i=0; i<trigger_->Events().size(); i++)
-            this->events_.push_back(target_->ValueRef());
+        for (size_t i=0; i<trigger_->Events().size(); i++)
+            this->Events().push_back(target_->Value());
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (! this->events_.empty())
-            Engine::OnNodePulse(*this, turn);
+        if (! this->Events().empty())
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "PulseNode"; }
-    virtual int         DependencyCount() const override    { return 2; }
+    virtual const char* GetNodeType() const override
+        { return "PulseNode"; }
+
+    virtual int GetDependencyCount() const override
+        { return 2; }
 
 private:
-    const std::shared_ptr<SignalNode<D,S>>      target_;
-    const std::shared_ptr<EventStreamNode<D,E>> trigger_;
+    const std::shared_ptr<SignalNode<S>>      target_;
+    const std::shared_ptr<EventStreamNode<E>> trigger_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/ContinuationNodes.h b/include/react/detail/graph/ContinuationNodes.h
deleted file mode 100644
index 6d494453..00000000
--- a/include/react/detail/graph/ContinuationNodes.h
+++ /dev/null
@@ -1,351 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_GRAPH_CONTINUATIONNODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_CONTINUATIONNODES_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <functional>
-#include <memory>
-#include <utility>
-
-#include "GraphBase.h"
-
-#include "react/detail/ReactiveInput.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
-class SignalNode;
-
-template <typename D, typename E>
-class EventStreamNode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AddContinuationRangeWrapper
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E, typename F, typename ... TArgs>
-struct AddContinuationRangeWrapper
-{
-    AddContinuationRangeWrapper(const AddContinuationRangeWrapper& other) = default;
-
-    AddContinuationRangeWrapper(AddContinuationRangeWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template
-    <
-        typename FIn,
-        class = typename DisableIfSame<FIn,AddContinuationRangeWrapper>::type
-    >
-    explicit AddContinuationRangeWrapper(FIn&& func) :
-        MyFunc( std::forward<FIn>(func) )
-    {}
-
-    void operator()(EventRange<E> range, const TArgs& ... args)
-    {
-        for (const auto& e : range)
-            MyFunc(e, args ...);
-    }
-
-    F MyFunc;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ContinuationNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class ContinuationNode : public NodeBase<D>
-{
-public:
-    ContinuationNode(TransactionFlagsT turnFlags) :
-        turnFlags_( turnFlags )
-    {}
-
-    virtual bool IsOutputNode() const { return true; }
-
-protected:
-    TransactionFlagsT turnFlags_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalContinuationNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename DOut,
-    typename S,
-    typename TFunc
->
-class SignalContinuationNode : public ContinuationNode<D>
-{
-    using Engine = typename SignalContinuationNode::Engine;
-
-public:
-    template <typename F>
-    SignalContinuationNode(TransactionFlagsT turnFlags,
-                           const std::shared_ptr<SignalNode<D,S>>& trigger, F&& func) :
-        SignalContinuationNode::ContinuationNode( turnFlags ),
-        trigger_( trigger ),
-        func_( std::forward<F>(func) )
-    {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *trigger);
-    }
-
-    ~SignalContinuationNode()
-    {
-        Engine::OnNodeDestroy(*this);
-    }
-
-    virtual const char* GetNodeType() const override        { return "SignalContinuationNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
-
-    virtual void Update(void* turnPtr) override
-    {
-#ifdef REACT_ENABLE_LOGGING
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-#endif
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        auto& storedValue = trigger_->ValueRef();
-        auto& storedFunc = func_;
-
-        TransactionFuncT cont
-        (
-            // Copy value and func
-            [storedFunc,storedValue] () mutable
-            {
-                storedFunc(storedValue);
-            }
-        );
-
-        DomainSpecificInputManager<D>::Instance()
-            .StoreContinuation(
-                DomainSpecificInputManager<DOut>::Instance(),
-                this->turnFlags_,
-                std::move(cont));
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-    }
-
-private:
-    std::shared_ptr<SignalNode<D,S>> trigger_;
-
-    TFunc   func_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventContinuationNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename DOut,
-    typename E,
-    typename TFunc
->
-class EventContinuationNode : public ContinuationNode<D>
-{
-    using Engine = typename EventContinuationNode::Engine;
-
-public:
-    template <typename F>
-    EventContinuationNode(TransactionFlagsT turnFlags,
-                          const std::shared_ptr<EventStreamNode<D,E>>& trigger, F&& func) :
-        EventContinuationNode::ContinuationNode( turnFlags ),
-        trigger_( trigger ),
-        func_( std::forward<F>(func) )
-    {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *trigger);
-    }
-
-    ~EventContinuationNode()
-    {
-        Engine::OnNodeDestroy(*this);
-    }
-
-    virtual const char* GetNodeType() const override        { return "EventContinuationNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
-
-    virtual void Update(void* turnPtr) override
-    {
-#ifdef REACT_ENABLE_LOGGING
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-#endif
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        auto& storedEvents = trigger_->Events();
-        auto& storedFunc = func_;
-
-        TransactionFuncT cont
-        (
-            // Copy events and func
-            [storedFunc,storedEvents] () mutable
-            {
-                storedFunc(EventRange<E>( storedEvents ));
-            }
-        );
-
-        DomainSpecificInputManager<D>::Instance()
-            .StoreContinuation(
-                DomainSpecificInputManager<DOut>::Instance(),
-                this->turnFlags_,
-                std::move(cont));
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-    }
-
-private:
-    std::shared_ptr<EventStreamNode<D,E>> trigger_;
-
-    TFunc   func_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedContinuationNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename DOut,
-    typename E,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedContinuationNode : public ContinuationNode<D>
-{
-    using Engine = typename SyncedContinuationNode::Engine;
-
-    using ValueTupleT = std::tuple<TDepValues...>;
-
-    struct TupleBuilder_
-    {
-        ValueTupleT operator()(const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps)
-        {
-            return ValueTupleT(deps->ValueRef() ...);
-        }
-    };
-
-    struct EvalFunctor_
-    {
-        EvalFunctor_(const E& e, TFunc& f) :
-            MyEvent( e ),
-            MyFunc( f )
-        {}
-
-        void operator()(const TDepValues& ... vals)
-        {
-            MyFunc(MyEvent, vals ...);
-        }
-
-        const E&    MyEvent;
-        TFunc&      MyFunc;
-    };
-
-public:
-    template <typename F>
-    SyncedContinuationNode(TransactionFlagsT turnFlags,
-                           const std::shared_ptr<EventStreamNode<D,E>>& trigger, F&& func, 
-                           const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedContinuationNode::ContinuationNode( turnFlags ),
-        trigger_( trigger ),
-        func_( std::forward<F>(func) ),
-        deps_( deps ... )
-    {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *trigger);
-
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
-    }
-
-    ~SyncedContinuationNode()
-    {
-        Engine::OnNodeDetach(*this, *trigger_);
-
-        apply(
-            DetachFunctor<D,SyncedContinuationNode,
-                std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-            deps_);
-
-        Engine::OnNodeDestroy(*this);
-    }
-
-    virtual const char* GetNodeType() const override        { return "SyncedContinuationNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
-
-    virtual void Update(void* turnPtr) override
-    {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        // Update of this node could be triggered from deps,
-        // so make sure source doesnt contain events from last turn
-        trigger_->SetCurrentTurn(turn);
-
-        auto& storedEvents = trigger_->Events();
-        auto& storedFunc = func_;
-
-        // Copy values to tuple
-        ValueTupleT storedValues = apply(TupleBuilder_( ), deps_);
-
-        // Note: MSVC error, if using () initialization.
-        // Probably a compiler bug.
-        TransactionFuncT cont
-        {
-            // Copy events, func, value tuple (note: 2x copy)
-            [storedFunc,storedEvents,storedValues] () mutable
-            {
-                apply(
-                    [&storedFunc,&storedEvents] (const TDepValues& ... vals)
-                    {
-                        storedFunc(EventRange<E>( storedEvents ), vals ...);
-                    },
-                    storedValues);
-            }
-        };
-
-        DomainSpecificInputManager<D>::Instance()
-            .StoreContinuation(
-                DomainSpecificInputManager<DOut>::Instance(),
-                this->turnFlags_,
-                std::move(cont));
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-    }
-
-private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
-
-    std::shared_ptr<EventStreamNode<D,E>> trigger_;
-    
-    TFunc       func_;
-    DepHolderT  deps_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_GRAPH_CONTINUATIONNODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 00e35cbf..a68df789 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -15,13 +15,55 @@
 #include <deque>
 #include <memory>
 #include <utility>
+#include <vector>
 
-#include "tbb/spin_mutex.h"
+//#include "tbb/spin_mutex.h"
 
 #include "GraphBase.h"
-#include "react/common/Concurrency.h"
 #include "react/common/Types.h"
 
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Iterators for event processing
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+class EventRange
+{
+public:
+    using const_iterator = typename std::vector<T>::const_iterator;
+    using size_type = typename std::vector<T>::size_type;
+
+    EventRange() = delete;
+
+    EventRange(const EventRange&) = default;
+    EventRange& operator=(const EventRange&) = default;
+
+    explicit EventRange(const std::vector<T>& data) :
+        data_( data )
+        { }
+
+    const_iterator begin() const
+        { return data_.begin(); }
+
+    const_iterator end() const
+        { return data_.end(); }
+
+    size_type GetSize() const
+        { return data_.size(); }
+
+    bool IsEmpty() const
+        { return data_.empty(); }
+
+private:
+    const std::vector<T>&    data_;
+};
+
+template <typename T>
+using EventSink = std::back_insert_iterator<std::vector<T>>;
+
+/******************************************/ REACT_END /******************************************/
+
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -39,27 +81,27 @@ class EventStreamNode : public NodeBase
 public:
     using StorageType = std::vector<T>;
 
-    EventStreamNode(IReactiveGroup* group) : NodeBase( group )
-        { }
-
-    EventStreamNode(NodeBase&&) = default;
-    EventStreamNode& operator=(NodeBase&&) = default;
+    EventStreamNode(EventStreamNode&&) = default;
+    EventStreamNode& operator=(EventStreamNode&&) = default;
 
-    EventStreamNode(const NodeBase&) = delete;
-    EventStreamNode& operator=(const NodeBase&) = delete;
+    EventStreamNode(const EventStreamNode&) = delete;
+    EventStreamNode& operator=(const EventStreamNode&) = delete;
 
-    void SetCurrentTurn(const TurnT& turn, bool forceUpdate = false, bool noClear = false)
+    void SetCurrentTurn(TurnId turnId, bool forceUpdate = false, bool noClear = false)
     {
-        this->AccessBufferForClearing([&] {
-            if (curTurnId_ != turn.Id() || forceUpdate)
-            {
-                curTurnId_ =  turn.Id();
-                if (!noClear)
-                    events_.clear();
-            }
-        });
+        //this->AccessBufferForClearing([&] {
+        //    if (curTurnId_ != turn.Id() || forceUpdate)
+        //    {
+        //        curTurnId_ =  turn.Id();
+        //        if (!noClear)
+        //            events_.clear();
+        //    }
+        //});
     }
 
+    explicit EventStreamNode(const std::shared_ptr<IReactiveGraph>& graphPtr) : NodeBase( graphPtr )
+        { }
+
     StorageType&  Events()
         { return events_; }
 
@@ -77,10 +119,10 @@ class EventStreamNode : public NodeBase
 /// EventSourceNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class EventSourceNode : public EventStreamNode<T>, public IInputNode
+class EventSourceNode : public EventStreamNode<T>
 {
 public:
-    EventSourceNode(IReactiveGroup* group) : EventSourceNode::EventStreamNode( group )
+    EventSourceNode(const std::shared_ptr<IReactiveGraph>& graphPtr) : EventSourceNode::EventStreamNode( graphPtr )
         { this->RegisterMe(); }
 
     ~EventSourceNode()
@@ -92,41 +134,35 @@ class EventSourceNode : public EventStreamNode<T>, public IInputNode
     virtual bool IsInputNode() const override
         { return true; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return 0; }
 
-    virtual void Update(void* turnPtr) override
-        { REACT_ASSERT(false, "Updated EventSourceNode\n"); }
-
-    template <typename V>
-    void AddInput(V&& v)
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        // Clear input from previous turn
-        if (changedFlag_)
+        if (this->Events().size() > 0 && !changedFlag_)
         {
-            changedFlag_ = false;
-            this->events_.clear();
+            this->SetCurrentTurn(turnId, true, true);
+            changedFlag_ = true;
+            
+            return UpdateResult::changed;
+        }
+        else
+        {
+            return UpdateResult::unchanged;
         }
-
-        this->events_.push_back(std::forward<V>(v));
     }
 
-    virtual bool ApplyInput(void* turnPtr) override
+    template <typename U>
+    void EmitValue(U&& value)
     {
-        if (this->events_.size() > 0 && !changedFlag_)
-        {
-            using TurnT = typename D::Engine::TurnT;
-            TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-            this->SetCurrentTurn(turn, true, true);
-            changedFlag_ = true;
-            Engine::OnInputChange(*this, turn);
-            return true;
-        }
-        else
+        // Clear input from previous turn
+        if (changedFlag_)
         {
-            return false;
+            changedFlag_ = false;
+            this->Events().clear();
         }
+
+        this->Events().push_back(std::forward<U>(value));
     }
 
 private:
@@ -140,8 +176,8 @@ template <typename TOut, typename ... TIns>
 class EventMergeNode : public EventStreamNode<TOut>
 {
 public:
-    EventMergeNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIns>>& ... deps) :
-        EventMergeNode::EventStreamNode( group ),
+    EventMergeNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIns>>& ... deps) :
+        EventMergeNode::EventStreamNode( graphPtr ),
         depHolder_( deps ... )
     {
         this->RegisterMe();
@@ -154,9 +190,9 @@ class EventMergeNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        // this->SetCurrentTurn(turn, true);
+        this->SetCurrentTurn(turnId, true);
 
         apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
@@ -169,115 +205,18 @@ class EventMergeNode : public EventStreamNode<TOut>
     virtual const char* GetNodeType() const override
         { return "EventMerge"; }
 
-    virtual int DependencyCount() const override
-        { return sizeof...(Es); }
+    virtual int GetDependencyCount() const override
+        { return sizeof...(TIns); }
 
 private:
     template <typename U>
-    void MergeFromDep(const std::shared_ptr<EventStreamNode<U>& other)
+    void MergeFromDep(const std::shared_ptr<EventStreamNode<U>>& other)
     {
         //arg->SetCurrentTurn(turn);
         this->Events().insert(this->Events().end(), other->Events().begin(), other->Events().end());
     }
 
-    std::tuple<std::shared_ptr<EventStreamNode<TIns> ...> depHolder_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventTransformNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TOut, typename TIn, typename F>
-class EventTransformNode : public EventStreamNode<TOut>
-{
-public:
-    template <typename U>
-    EventTransformNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func) :
-        EventTransformNode::EventStreamNode( group ),
-        dep_( dep ),
-        func_( std::forward<U>(func) )
-    {
-        this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
-    }
-
-    ~EventTransformNode()
-    {
-        this->DetachFromMe(dep_->GetNodeId());
-        this->UnregisterMe();
-    }
-
-    virtual UpdateResult Update() override
-    {
-        // this->SetCurrentTurn(turn, true);
-
-        for (const auto& v : dep_->Events())
-            this->Events().push_back(func_(v));
-
-        if (! this->Events().empty())
-            return UpdateResult::changed;
-        else
-            return UpdateResult::unchanged;
-    }
-
-    virtual const char* GetNodeType() const override
-        { return "EventTransform"; }
-
-    virtual int DependencyCount() const override
-        { return 1; }
-
-private:
-    std::shared_ptr<EventStreamNode<TIn> dep_;
-
-    F func_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventFilterNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F>
-class EventFilterNode : public EventStreamNode<T>
-{
-public:
-    template <typename U>
-    EventFilterNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<T>>& dep, U&& pred) :
-        EventFilterNode::EventStreamNode( group ),
-        dep_( dep ),
-        pred_( std::forward<U>(pred) )
-    {
-        this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
-    }
-
-    ~EventFilterNode()
-    {
-        this->DetachFromMe(dep_->GetNodeId());
-        this->UnregisterMe();
-    }
-
-    virtual UpdateResult Update() override
-    {
-        // this->SetCurrentTurn(turn, true);
-
-        for (const auto& v : dep_->Events())
-            if (pred_(v))
-                this->Events().push_back(v);
-
-        if (! this->Events().empty())
-            return UpdateResult::changed;
-        else
-            return UpdateResult::unchanged;
-    }
-
-    virtual const char* GetNodeType() const override
-        { return "EventFilter"; }
-
-    virtual int DependencyCount() const override
-        { return 1; }
-
-private:
-    std::shared_ptr<EventStreamNode<T> dep_;
-
-    F pred_;
+    std::tuple<std::shared_ptr<EventStreamNode<TIns>> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -287,8 +226,8 @@ template <typename TOuter, typename TInner>
 class EventFlattenNode : public EventStreamNode<TInner>
 {
 public:
-    EventFlattenNode(IReactiveGroup* group, const std::shared_ptr<SignalNode<TOuter>>& outer, const std::shared_ptr<EventStreamNode<TInner>>& inner) :
-        EventFlattenNode::EventStreamNode( group ),
+    EventFlattenNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<TOuter>>& outer, const std::shared_ptr<EventStreamNode<TInner>>& inner) :
+        EventFlattenNode::EventStreamNode( graphPtr ),
         outer_( outer ),
         inner_( inner )
     {
@@ -310,19 +249,19 @@ class EventFlattenNode : public EventStreamNode<TInner>
     virtual bool IsDynamicNode() const override
         { return true; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return 2; }
 
-    virtual UpdateResult Update() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        // this->SetCurrentTurn(turn, true);
-        // inner_->SetCurrentTurn(turn);
+        this->SetCurrentTurn(turnId, true);
+        inner_->SetCurrentTurn(turnId);
 
-        auto newInner = GetNodePtr(outer_->ValueRef());
+        auto newInner = GetNodePtr(outer_->Value());
 
         if (newInner != inner_)
         {
-            newInner->SetCurrentTurn(turn);
+            newInner->SetCurrentTurn(turnId);
 
             // Topology has been changed
             auto oldInner = inner_;
@@ -347,121 +286,6 @@ class EventFlattenNode : public EventStreamNode<TInner>
     std::shared_ptr<EventStreamNode<TInner>>  inner_;
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedEventTransformNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TOut, typename TIn, typename F, typename ... TSyncs>
-class SyncedEventTransformNode : public EventStreamNode<TOut>
-{
-public:
-    template <typename U>
-    SyncedEventTransformNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedEventTransformNode::EventStreamNode( group ),
-        dep_( dep ),
-        func_( std::forward<U>(func) ),
-        syncs_( syncs ... )
-    {
-        this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
-        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
-    }
-
-    ~SyncedEventTransformNode()
-    {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(dep_->GetNodeId());
-        this->UnregisterMe();
-    }
-
-    virtual UpdateResult Update() override
-    {
-        //this->SetCurrentTurn(turn, true);
-
-        // Update of this node could be triggered from deps,
-        // so make sure source doesnt contain events from last turn
-        // source_->SetCurrentTurn(turn);
-
-        for (const auto& e : dep_->Events())
-            this->Events().push_back(apply([this, &e] (const auto& ... syncs) { return this->func_(e, syncs->ValueRef() ...); }, syncHolder_));
-
-        if (! this->Events().empty())
-            return UpdateResult::changed;
-        else
-            return UpdateResult::unchanged;
-    }
-
-    virtual const char* GetNodeType() const override
-        { return "SyncedEventTransform"; }
-
-    virtual int DependencyCount() const override
-        { return 1 + sizeof...(TSyncs); }
-
-private:
-    std::shared_ptr<EventStreamNode<TIn>>   dep_;
-
-    F func_;
-
-    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedEventFilterNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F, typename ... TSyncs>
-class SyncedEventFilterNode : public EventStreamNode<T>
-{
-public:
-    template <typename U>
-    SyncedEventFilterNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<T>>& dep, U&& pred, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedEventFilterNode::EventStreamNode( group ),
-        dep_( dep ),
-        pred_( std::forward<F>(pred) ),
-        syncs_( syncs ... )
-    {
-        this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
-        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
-    }
-
-    ~SyncedEventFilterNode()
-    {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(dep_->GetNodeId());
-        this->UnregisterMe();
-    }
-
-    virtual UpdateResult Update() override
-    {
-        // this->SetCurrentTurn(turn, true);
-
-        // Update of this node could be triggered from deps,
-        // so make sure source doesnt contain events from last turn
-        //source_->SetCurrentTurn(turn);
-
-        for (const auto& e : dep_->Events())
-            if (apply([this, &e] (const auto& ... syncs) { return this->func_(e, syncs->ValueRef() ...); }, syncHolder_))
-                this->Events().push_back(e);
-
-        if (! this->Events().empty())
-            return UpdateResult::changed;
-        else
-            return UpdateResult::unchanged;
-    }
-
-    virtual const char* GetNodeType() const override
-        { return "SyncedEventFilter"; }
-
-    virtual int DependencyCount() const override
-        { return 1 + sizeof...(TSyncs); }
-
-private:
-    std::shared_ptr<EventStreamNode<TIn>>   dep_;
-
-    F pred_;
-
-    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventProcessingNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -470,8 +294,8 @@ class EventProcessingNode : public EventStreamNode<TOut>
 {
 public:
     template <typename U>
-    EventProcessingNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func) :
-        EventProcessingNode::EventStreamNode( group ),
+    EventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func) :
+        EventProcessingNode::EventStreamNode( graphPtr ),
         dep_( dep ),
         func_( std::forward<U>(func) )
     {
@@ -485,11 +309,11 @@ class EventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        //this->SetCurrentTurn(turn, true);
+        this->SetCurrentTurn(turnId, true);
 
-        func_(EventRange<TIn>( source_->Events() ), std::back_inserter(this->Events()));
+        func_(EventRange<TIn>( dep_->Events() ), std::back_inserter(this->Events()));
 
         if (! this->Events().empty())
             return UpdateResult::changed;
@@ -500,13 +324,13 @@ class EventProcessingNode : public EventStreamNode<TOut>
     virtual const char* GetNodeType() const override
         { return "EventProcessing"; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return 1; }
 
 private:
-    std::shared_ptr<EventStreamNode<D,TIn>>   source_;
+    std::shared_ptr<EventStreamNode<TIn>> dep_;
 
-    TFunc       func_;
+    F func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -517,11 +341,11 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 {
 public:
     template <typename U>
-    SyncedEventProcessingNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedEventProcessingNode::EventStreamNode( group ),
+    SyncedEventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedEventProcessingNode::EventStreamNode( graphPtr ),
         dep_( dep ),
         func_( std::forward<U>(func) ),
-        syncs_( syncs ... )
+        syncHolder_( syncs ... )
     {
         this->RegisterMe();
         this->AttachToMe(dep->GetNodeId());
@@ -535,17 +359,17 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        //this->SetCurrentTurn(turn, true);
+        this->SetCurrentTurn(turnId, true);
         // Update of this node could be triggered from deps,
         // so make sure source doesnt contain events from last turn
-        //source_->SetCurrentTurn(turn);
+        source_->SetCurrentTurn(turnId);
 
         apply(
             [this] (const auto& ... syncs)
             {
-                func_(EventRange<TIn>( source_->Events() ), std::back_inserter(this->Events()), syncs->ValueRef() ...);
+                func_(EventRange<TIn>( this->dep_->Events() ), std::back_inserter(this->Events()), syncs->Value() ...);
             },
             syncHolder_);
 
@@ -558,7 +382,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
     virtual const char* GetNodeType() const override
         { return "SycnedEventProcessing"; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return 1 + sizeof...(TSyncs); }
 
 private:
@@ -576,8 +400,8 @@ template <typename ... Ts>
 class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 {
 public:
-    EventJoinNode(IReactiveGroup* group, const std::shared_ptr<EventStreamNode<Ts>>& ... deps) :
-        EventJoinNode::EventStreamNode( group ),
+    EventJoinNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<Ts>>& ... deps) :
+        EventJoinNode::EventStreamNode( graphPtr ),
         slots_( deps ... )
     {
         this->RegisterMe();
@@ -590,12 +414,12 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        //this->SetCurrentTurn(turn, true);
+        this->SetCurrentTurn(turnId, true);
 
         // Move events into buffers
-        apply([this, &turn] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turn, slots)); }, slots_);
+        apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
 
         while (true)
         {
@@ -631,7 +455,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     virtual const char* GetNodeType() const override
         { return "EventJoin"; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return sizeof...(Ts); }
 
 private:
@@ -647,9 +471,9 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     };
 
     template <typename U>
-    static void FetchBuffer(TurnT& turn, Slot<U>& slot)
+    static void FetchBuffer(TurnId turnId, Slot<U>& slot)
     {
-        //slot.Source->SetCurrentTurn(turn);
+        slot.Source->SetCurrentTurn(turnId);
         slot.buffer.insert(slot.buffer.end(), slot.source->Events().begin(), slot.source->Events().end());
     }
 
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 404108d0..43d091da 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -11,76 +11,18 @@
 
 #include "react/detail/Defs.h"
 
+#include <iterator>
 #include <memory>
 #include <utility>
 
-#include "react/common/Util.h"
-#include "react/common/Timing.h"
 #include "react/common/Types.h"
-#include "react/detail/IReactiveGroup.h"
-#include "react/detail/IReactiveNode.h"
+#include "react/common/Util.h"
+#include "react/detail/IReactiveGraph.h"
 #include "react/detail/ObserverBase.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// WeightHint
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum class WeightHint
-{
-    automatic,
-    light,
-    heavy
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// UpdateTimingPolicy
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    long long threshold
->
-class UpdateTimingPolicy :
-    private ConditionalTimer<threshold, D::uses_node_update_timer>
-{
-    using ScopedTimer = typename UpdateTimingPolicy::ScopedTimer;
-
-public:
-    class ScopedUpdateTimer : private ScopedTimer
-    {
-    public:
-        ScopedUpdateTimer(UpdateTimingPolicy& parent, const size_t& count) :
-            ScopedTimer( parent, count )
-        {}
-    };
-
-    void ResetUpdateThreshold()                 { this->Reset(); }
-    void ForceUpdateThresholdExceeded(bool v)   { this->ForceThresholdExceeded(v); }
-    bool IsUpdateThresholdExceeded() const      { return this->IsThresholdExceeded(); }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DepCounter
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct CountHelper { static const int value = T::dependency_count; };
-
-template <typename T>
-struct CountHelper<std::shared_ptr<T>> { static const int value = 1; };
-
-template <int N, typename... Args>
-struct DepCounter;
-
-template <>
-struct DepCounter<0> { static int const value = 0; };
-
-template <int N, typename First, typename... Args>
-struct DepCounter<N, First, Args...>
-{
-    static int const value =
-        CountHelper<typename std::decay<First>::type>::value + DepCounter<N-1,Args...>::value;
-};
+struct IReactiveGraph;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// NodeBase
@@ -88,13 +30,14 @@ struct DepCounter<N, First, Args...>
 class NodeBase : public IReactiveNode
 {
 public:
-    NodeBase(IReactiveGroup* group) : group_( group )
+    NodeBase(const std::shared_ptr<IReactiveGraph>& graphPtr) : graphPtr_( graphPtr )
         { }
+    
+    NodeBase(const NodeBase&) = delete;
+    NodeBase& operator=(const NodeBase&) = delete;
 
     NodeBase(NodeBase&&) = delete;
     NodeBase& operator=(NodeBase&&) = delete;
-    NodeBase(const NodeBase&) = delete;
-    NodeBase& operator=(const NodeBase&) = delete;
     
     virtual bool IsInputNode() const override
         { return false; }
@@ -104,11 +47,8 @@ class NodeBase : public IReactiveNode
 
     virtual bool IsDynamicNode() const override
         { return false; }
-    
-    virtual bool IsHeavyweight() const override 
-        { return false; }
 
-    void SetWeightHint(WeightHint weight)
+    /*void SetWeightHint(WeightHint weight)
     {
         switch (weight)
         {
@@ -122,174 +62,42 @@ class NodeBase : public IReactiveNode
             this->ResetUpdateThreshold();
             break;
         }
-    }
+    }*/
 
     NodeId GetNodeId() const
         { return nodeId_; }
 
+    auto GraphPtr() const -> const std::shared_ptr<IReactiveGraph>&
+        { return graphPtr_; }
+
+    auto GraphPtr() -> std::shared_ptr<IReactiveGraph>&
+        { return graphPtr_; }
+
 protected:
     void RegisterMe()
-        { nodeId_ = group_->RegisterNode(); }
+        { nodeId_ = graphPtr_->RegisterNode(this); }
     
     void UnregisterMe()
-        { group_->UnregisterNode(nodeId_); }
+        { graphPtr_->UnregisterNode(nodeId_); }
 
     void AttachToMe(NodeId otherNodeId)
-        { group_->OnNodeAttach(nodeId_, otherNodeId); }
+        { graphPtr_->OnNodeAttach(nodeId_, otherNodeId); }
 
     void DetachFromMe(NodeId otherNodeId)
-        { group_->OnNodeDetach(nodeId_, otherNodeId); }
+        { graphPtr_->OnNodeDetach(nodeId_, otherNodeId); }
 
     void DynamicAttachToMe(NodeId otherNodeId, TurnId turnId)
-        { group_->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
+        { graphPtr_->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
 
     void DynamicDetachFromMe(NodeId otherNodeId, TurnId turnId)
-        { group_->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
+        { graphPtr_->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
 
 private:
     NodeId          nodeId_;
-    IReactiveGroup* group_;
-};
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Attach/detach helper functors
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode, typename ... TDeps>
-struct AttachFunctor
-{
-    AttachFunctor(TNode& node) : MyNode( node ) {}
-
-    void operator()(const TDeps& ...deps) const
-    {
-        REACT_EXPAND_PACK(attach(deps));
-    }
-
-    template <typename T>
-    void attach(const T& op) const
-    {
-        op.template AttachRec<D,TNode>(*this);
-    }
-
-    template <typename T>
-    void attach(const std::shared_ptr<T>& depPtr) const
-    {
-        D::Engine::OnNodeAttach(MyNode, *depPtr);
-    }
-
-    TNode& MyNode;
+    std::shared_ptr<IReactiveGraph> graphPtr_;
 };
 
-template <typename D, typename TNode, typename ... TDeps>
-struct DetachFunctor
-{
-    DetachFunctor(TNode& node) : MyNode( node ) {}
-
-    void operator()(const TDeps& ... deps) const
-    {
-        REACT_EXPAND_PACK(detach(deps));
-    }
-
-    template <typename T>
-    void detach(const T& op) const
-    {
-        op.template DetachRec<D,TNode>(*this);
-    }
-
-    template <typename T>
-    void detach(const std::shared_ptr<T>& depPtr) const
-    {
-        D::Engine::OnNodeDetach(MyNode, *depPtr);
-    }
-
-    TNode& MyNode;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ReactiveOpBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename ... TDeps>
-class ReactiveOpBase
-{
-public:
-    using DepHolderT = std::tuple<TDeps...>;
-
-    template <typename ... TDepsIn>
-    ReactiveOpBase(DontMove, TDepsIn&& ... deps) :
-        deps_( std::forward<TDepsIn>(deps) ... )
-    {}
-
-    ReactiveOpBase(ReactiveOpBase&& other) :
-        deps_( std::move(other.deps_) )
-    {}
-
-    // Can't be copied, only moved
-    ReactiveOpBase(const ReactiveOpBase& other) = delete;
-
-    template <typename D, typename TNode>
-    void Attach(TNode& node) const
-    {
-        apply(AttachFunctor<D,TNode,TDeps...>{ node }, deps_);
-    }
-
-    template <typename D, typename TNode>
-    void Detach(TNode& node) const
-    {
-        apply(DetachFunctor<D,TNode,TDeps...>{ node }, deps_);
-    }
-
-    template <typename D, typename TNode, typename TFunctor>
-    void AttachRec(const TFunctor& functor) const
-    {
-        // Same memory layout, different func
-        apply(reinterpret_cast<const AttachFunctor<D,TNode,TDeps...>&>(functor), deps_);
-    }
-
-    template <typename D, typename TNode, typename TFunctor>
-    void DetachRec(const TFunctor& functor) const
-    {
-        apply(reinterpret_cast<const DetachFunctor<D,TNode,TDeps...>&>(functor), deps_);
-    }
-
-public:
-    static const int dependency_count = DepCounter<sizeof...(TDeps), TDeps...>::value;
-
-protected:
-    DepHolderT   deps_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterators for event processing
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class EventRange
-{
-public:
-    using const_iterator = typename std::vector<E>::const_iterator;
-    using size_type = typename std::vector<E>::size_type;
-
-    // Copy ctor
-    EventRange(const EventRange&) = default;
-
-    // Copy assignment
-    EventRange& operator=(const EventRange&) = default;
-
-    const_iterator begin() const    { return data_.begin(); }
-    const_iterator end() const      { return data_.end(); }
-
-    size_type   Size() const        { return data_.size(); }
-    bool        IsEmpty() const     { return data_.empty(); }
-
-    explicit EventRange(const std::vector<E>& data) :
-        data_( data )
-    {}
-
-private:
-    const std::vector<E>&    data_;
-};
-
-template <typename E>
-using EventEmitter = std::back_insert_iterator<std::vector<E>>;
-
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_GRAPHBASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index b597e828..b90e118e 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -23,337 +23,167 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename S>
+template <typename T>
 class SignalNode;
 
-template <typename D, typename E>
+template <typename T>
 class EventStreamNode;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObserverAction
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum class ObserverAction
-{
-    next,
-    stop_and_detach
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AddObserverRangeWrapper
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E, typename F, typename ... TArgs>
-struct AddObserverRangeWrapper
-{
-    AddObserverRangeWrapper(const AddObserverRangeWrapper& other) = default;
-
-    AddObserverRangeWrapper(AddObserverRangeWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template
-    <
-        typename FIn,
-        class = typename DisableIfSame<FIn,AddObserverRangeWrapper>::type
-    >
-    explicit AddObserverRangeWrapper(FIn&& func) :
-        MyFunc( std::forward<FIn>(func) )
-    {}
-
-    ObserverAction operator()(EventRange<E> range, const TArgs& ... args)
-    {
-        for (const auto& e : range)
-            if (MyFunc(e, args ...) == ObserverAction::stop_and_detach)
-                return ObserverAction::stop_and_detach;
-
-        return ObserverAction::next;
-    }
-
-    F MyFunc;
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class ObserverNode :
-    public NodeBase<D>,
-    public IObserver
+class ObserverNode : public NodeBase, public IObserver
 {
 public:
-    ObserverNode() = default;
+    ObserverNode(IReactiveGraph* group) : NodeBase( group )
+        { }
+
+    ObserverNode(ObserverNode&&) = default;
+    ObserverNode& operator=(ObserverNode&&) = default;
 
-    virtual bool IsOutputNode() const { return true; }
+    ObserverNode(const ObserverNode&) = delete;
+    ObserverNode& operator=(const ObserverNode&) = delete;
+
+    virtual bool IsOutputNode() const
+        { return true; }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename S,
-    typename TFunc
->
-class SignalObserverNode :
-    public ObserverNode<D>
+template <typename T, typename F>
+class SignalObserverNode : public ObserverNode
 {
-    using Engine = typename SignalObserverNode::Engine;
-
 public:
-    template <typename F>
-    SignalObserverNode(const std::shared_ptr<SignalNode<D,S>>& subject, F&& func) :
-        SignalObserverNode::ObserverNode( ),
+    template <typename FIn>
+    SignalObserverNode(IReactiveGraph* group, const std::shared_ptr<SignalNode<T>>& subject, FIn&& func) :
+        SignalObserverNode::ObserverNode( group ),
         subject_( subject ),
-        func_( std::forward<F>(func) )
+        func_( std::forward<FIn>(func) )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *subject);
+        this->RegisterMe();
+        this->AttachToMe(subject->GetNodeId());
     }
 
     ~SignalObserverNode()
     {
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(subject->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override        { return "SignalObserverNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
-
-    virtual void Update(void* turnPtr) override
-    {
-#ifdef REACT_ENABLE_LOGGING
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-#endif
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
+    virtual const char* GetNodeType() const override
+        { return "SignalObserver"; }
 
-        bool shouldDetach = false;
+    virtual int DependencyCount() const override
+        { return 1; }
 
-        if (auto p = subject_.lock())
-        {// timer
-            using TimerT = typename SignalObserverNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, 1 );
-            
-            if (func_(p->ValueRef()) == ObserverAction::stop_and_detach)
-                shouldDetach = true;
-        }// ~timer
-
-        if (shouldDetach)
-            DomainSpecificInputManager<D>::Instance()
-                .QueueObserverForDetach(*this);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-    }
-
-    virtual void UnregisterSelf() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        if (auto p = subject_.lock())
-            p->UnregisterObserver(this);
+        func_(subject_->Value());
+        return UpdateResult::unchanged;
     }
 
 private:
-    virtual void detachObserver() override
-    {
-        if (auto p = subject_.lock())
-        {
-            Engine::OnNodeDetach(*this, *p);
-            subject_.reset();
-        }
-    }
+    std::shared_ptr<SignalNode<T>> subject_;
 
-    std::weak_ptr<SignalNode<D,S>>  subject_;
-    TFunc                           func_;
+    F func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E,
-    typename TFunc
->
-class EventObserverNode :
-    public ObserverNode<D>
+template <typename T, typename F>
+class EventObserverNode : public ObserverNode
 {
-    using Engine = typename EventObserverNode::Engine;
-
 public:
-    template <typename F>
-    EventObserverNode(const std::shared_ptr<EventStreamNode<D,E>>& subject, F&& func) :
-        EventObserverNode::ObserverNode( ),
+    template <typename FIn>
+    EventObserverNode(IReactiveGraph* group, const std::shared_ptr<EventStreamNode<T>>& subject, FIn&& func) :
+        EventObserverNode::ObserverNode( group ),
         subject_( subject ),
-        func_( std::forward<F>(func) )
+        func_( std::forward<FIn>(func) )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *subject);
+        this->RegisterMe();
+        this->AttachToMe(subject->GetNodeId());
     }
 
     ~EventObserverNode()
     {
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(subject->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override        { return "EventObserverNode"; }
-    virtual int         DependencyCount() const override    { return 1; }
-
-    virtual void Update(void* turnPtr) override
-    {
-#ifdef REACT_ENABLE_LOGGING
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-#endif
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        bool shouldDetach = false;
-
-        if (auto p = subject_.lock())
-        {// timer
-            using TimerT = typename EventObserverNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, p->Events().size() );
+    virtual const char* GetNodeType() const override
+        { return "EventObserverNode"; }
 
-            shouldDetach = func_(EventRange<E>( p->Events() )) == ObserverAction::stop_and_detach;
+    virtual int DependencyCount() const override
+        { return 1; }
 
-        }// ~timer
-
-        if (shouldDetach)
-            DomainSpecificInputManager<D>::Instance()
-                .QueueObserverForDetach(*this);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-    }
-
-    virtual void UnregisterSelf() override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        if (auto p = subject_.lock())
-            p->UnregisterObserver(this);
+        func_(EventRange<T>( subject_->Events() ));
+        return UpdateResult::unchanged;
     }
 
 private:
-    std::weak_ptr<EventStreamNode<D,E>> subject_;
-
-    TFunc   func_;
+    std::shared_ptr<EventStreamNode<T>> subject_;
 
-    virtual void detachObserver()
-    {
-        if (auto p = subject_.lock())
-        {
-            Engine::OnNodeDetach(*this, *p);
-            subject_.reset();
-        }
-    }
+    F func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename E,
-    typename TFunc,
-    typename ... TDepValues
->
-class SyncedObserverNode :
-    public ObserverNode<D>
+template <typename T, typename F, typename ... TSyncs>
+class SyncedObserverNode : public ObserverNode
 {
-    using Engine = typename SyncedObserverNode::Engine;
-
 public:
-    template <typename F>
-    SyncedObserverNode(const std::shared_ptr<EventStreamNode<D,E>>& subject, F&& func, 
-                       const std::shared_ptr<SignalNode<D,TDepValues>>& ... deps) :
-        SyncedObserverNode::ObserverNode( ),
+    template <typename FIn>
+    SyncedObserverNode(IReactiveGraph* group, const std::shared_ptr<EventStreamNode<T>>& subject, FIn&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedObserverNode::ObserverNode( group ),
         subject_( subject ),
-        func_( std::forward<F>(func) ),
-        deps_( deps ... )
+        func_( std::forward<FIn>(func) ),
+        syncHolder_( syncs ... )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *subject);
-
-        REACT_EXPAND_PACK(Engine::OnNodeAttach(*this, *deps));
+        this->RegisterMe();
+        this->AttachToMe(subject->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedObserverNode()
     {
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(subject_->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override        { return "SyncedObserverNode"; }
-    virtual int         DependencyCount() const override    { return 1 + sizeof...(TDepValues); }
+    virtual const char* GetNodeType() const override
+        { return "SyncedObserverNode"; }
 
-    virtual void Update(void* turnPtr) override
-    {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-        
-        bool shouldDetach = false;
-
-        if (auto p = subject_.lock())
-        {
-            // Update of this node could be triggered from deps,
-            // so make sure source doesnt contain events from last turn
-            p->SetCurrentTurn(turn);
-
-            {// timer
-                using TimerT = typename SyncedObserverNode::ScopedUpdateTimer;
-                TimerT scopedTimer( *this, p->Events().size() );
+    virtual int DependencyCount() const override
+        { return 1 + sizeof...(TSyncs); }
+
+    virtual UpdateResult Update(TurnId turnId) override
+    {   
+        // Update of this node could be triggered from deps,
+        // so make sure source doesnt contain events from last turn
+        p->SetCurrentTurn(turnId);
             
-                shouldDetach = apply(
-                    [this, &p] (const std::shared_ptr<SignalNode<D,TDepValues>>& ... args)
-                    {
-                        return func_(EventRange<E>( p->Events() ), args->ValueRef() ...);
-                    },
-                    deps_) == ObserverAction::stop_and_detach;
-
-            }// ~timer
-        }
-
-        if (shouldDetach)
-            DomainSpecificInputManager<D>::Instance()
-                .QueueObserverForDetach(*this);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-    }
+        shouldDetach = apply(
+            [this] (const auto& ... syncs)
+            {
+                func_(EventRange<E>( this->subject_->Events() ), syncs->Value() ...);
+            },
+            syncHolder_);
 
-    virtual void UnregisterSelf() override
-    {
-        if (auto p = subject_.lock())
-            p->UnregisterObserver(this);
+        return UpdateResult::unchanged;
     }
 
 private:
-    using DepHolderT = std::tuple<std::shared_ptr<SignalNode<D,TDepValues>>...>;
-
-    std::weak_ptr<EventStreamNode<D,E>> subject_;
+    std::shared_ptr<EventStreamNode<T>> subject_;
     
-    TFunc       func_;
-    DepHolderT  deps_;
-
-    virtual void detachObserver()
-    {
-        if (auto p = subject_.lock())
-        {
-            Engine::OnNodeDetach(*this, *p);
-
-            apply(
-                DetachFunctor<D,SyncedObserverNode,
-                    std::shared_ptr<SignalNode<D,TDepValues>>...>( *this ),
-                deps_);
+    F func_;
 
-            subject_.reset();
-        }
-    }
+    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/PropagationMT.h b/include/react/detail/graph/PropagationMT.h
new file mode 100644
index 00000000..e69de29b
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
new file mode 100644
index 00000000..bfbc0828
--- /dev/null
+++ b/include/react/detail/graph/PropagationST.h
@@ -0,0 +1,284 @@
+
+//          Copyright Sebastian Jeckel 2016.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
+#define REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/Defs.h"
+
+#include <algorithm>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "react/common/Containers.h"
+#include "react/common/Types.h"
+#include "react/detail/IReactiveGraph.h"
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+class SingleThreadedGraph : public IReactiveGraph
+{
+public:
+    // IReactiveGraph
+    virtual NodeId RegisterNode(IReactiveNode* nodePtr) override;
+    virtual void UnregisterNode(NodeId node) override;
+
+    virtual void OnNodeAttach(NodeId node, NodeId parentId) override;
+    virtual void OnNodeDetach(NodeId node, NodeId parentId) override;
+
+    virtual void OnDynamicNodeAttach(NodeId node, NodeId parentId, TurnId turnId) override;
+    virtual void OnDynamicNodeDetach(NodeId node, NodeId parentId, TurnId turnId) override;
+
+    virtual void AddInput(NodeId nodeId, std::function<void()> inputCallback) override;
+    // ~IReactiveGraph
+
+    template <typename F>
+    void DoTransaction(TransactionFlags flags, F&& transactionCallback);
+
+private:
+    struct NodeData
+    {
+        NodeData() = default;
+
+        NodeData(const NodeData&) = default;
+        NodeData& operator=(const NodeData&) = default;
+
+        NodeData(IReactiveNode* nodePtrIn) :
+            nodePtr( nodePtrIn )
+        { }
+
+        int     level       = 0;
+        int     newLevel    = 0 ;
+        bool    queued      = false;
+
+        IReactiveNode*  nodePtr = nullptr;
+
+        std::vector<NodeId> successors;
+    };
+
+    class TopoQueue
+    {
+    public:
+        void Push(NodeId nodeId, int level)
+            { queueData_.emplace_back(nodeId, level); }
+
+        bool FetchNext();
+
+        const std::vector<NodeId>& Next() const
+            { return nextData_; }
+
+        bool IsEmpty() const
+            { return queueData_.empty(); }
+
+    private:
+        using Entry = std::pair<NodeId /*nodeId*/, int /*level*/>;
+
+        std::vector<Entry>  queueData_;
+        std::vector<NodeId> nextData_;
+
+        int minLevel_ = (std::numeric_limits<int>::max)();
+    };
+
+    void Propagate();
+
+    void ScheduleSuccessors(NodeData & node);
+    void InvalidateSuccessors(NodeData & node);
+
+private:
+    int refCount_ = 1;
+
+    TopoQueue           scheduledNodes_;
+    IndexMap<NodeData>  nodeData_;
+    std::vector<NodeId> changedInputs_;
+
+    bool isTransactionActive_ = false;
+};
+
+NodeId SingleThreadedGraph::RegisterNode(IReactiveNode* nodePtr)
+{
+    return nodeData_.Insert(NodeData{ nodePtr });
+}
+
+void SingleThreadedGraph::UnregisterNode(NodeId nodeId)
+{
+    nodeData_.Remove(nodeId);
+
+}
+
+void SingleThreadedGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
+{
+    auto& node = nodeData_[nodeId];
+    auto& parent = nodeData_[parentId];
+
+    parent.successors.push_back(nodeId);
+
+    if (node.level <= parent.level)
+        node.level = parent.level + 1;
+}
+
+void SingleThreadedGraph::OnNodeDetach(NodeId nodeId, NodeId parentId)
+{
+    auto& parent = nodeData_[parentId];
+    auto& successors = parent.successors;
+
+    successors.erase(std::find(successors.begin(), successors.end(), nodeId));
+}
+
+void SingleThreadedGraph::OnDynamicNodeAttach(NodeId nodeId, NodeId parentId, TurnId turnId)
+{
+    OnNodeAttach(nodeId, parentId);
+}
+
+void SingleThreadedGraph::OnDynamicNodeDetach(NodeId nodeId, NodeId parentId, TurnId turnId)
+{
+    OnNodeDetach(nodeId, parentId);
+}
+
+void SingleThreadedGraph::AddInput(NodeId nodeId, std::function<void()> inputCallback)
+{
+    auto& node = nodeData_[nodeId];
+    auto* nodePtr = node.nodePtr;
+
+    // This write to the input buffer of the respective node.
+    inputCallback();
+    
+    if (isTransactionActive_)
+    {
+        // If a transaction is active, don't propagate immediately.
+        // Instead, record the node and wait for more inputs.
+        changedInputs_.push_back(nodeId);
+    }
+    else
+    {
+        // Update the node. This applies the input buffer to the node value and checks if it changed.
+        if (nodePtr->Update(0) == UpdateResult::changed)
+        {
+            // Propagate changes through the graph
+            ScheduleSuccessors(node);
+
+            if (! scheduledNodes_.IsEmpty())
+                Propagate();
+        }       
+    }
+}
+
+template <typename F>
+void SingleThreadedGraph::DoTransaction(TransactionFlags flags, F&& transactionCallback)
+{
+    // Transaction callback may add multiple inputs.
+    isTransactionActive_ = true;
+    std::forward<F>(transactionCallback)();
+    isTransactionActive_ = false;
+
+    // Apply all buffered inputs.
+    for (NodeId nodeId : changedInputs_)
+    {
+        auto& node = nodeData_[nodeId];
+
+        if (node.nodePtr->Update(0) == UpdateResult::changed)
+            ScheduleSuccessors(node);
+    }
+
+    changedInputs_.clear();
+
+    // Propagate changes through the graph.
+    if (! scheduledNodes_.IsEmpty())
+        Propagate();
+}
+
+void SingleThreadedGraph::Propagate()
+{
+    while (scheduledNodes_.FetchNext())
+    {
+        for (NodeId nodeId : scheduledNodes_.Next())
+        {
+            auto& node = nodeData_[nodeId];
+
+            if (node.level < node.newLevel)
+            {
+                // Re-schedule this node
+                node.level = node.newLevel;
+                InvalidateSuccessors(node);
+                scheduledNodes_.Push(nodeId, node.level);
+                continue;
+            }
+
+            auto result = node.nodePtr->Update(0);
+
+            if (result == UpdateResult::changed)
+            {
+                ScheduleSuccessors(node);
+            }
+            else if (result == UpdateResult::shifted)
+            {
+                // Re-schedule this node
+                InvalidateSuccessors(node);
+                scheduledNodes_.Push(nodeId, node.level);
+                continue;
+            }
+
+            node.queued = false;
+        }
+    }
+}
+
+void SingleThreadedGraph::ScheduleSuccessors(NodeData& node)
+{
+    for (NodeId succId : node.successors)
+    {
+        auto& succ = nodeData_[succId];
+
+        if (!succ.queued)
+        {
+            succ.queued = true;
+            scheduledNodes_.Push(succId, succ.level);
+        }
+    }
+}
+
+void SingleThreadedGraph::InvalidateSuccessors(NodeData& node)
+{
+    for (NodeId succId : node.successors)
+    {
+        auto& succ = nodeData_[succId];
+
+        if (succ.newLevel <= node.level)
+            succ.newLevel = node.level + 1;
+    }
+}
+
+bool SingleThreadedGraph::TopoQueue::FetchNext()
+{
+    // Throw away previous values
+    nextData_.clear();
+
+    // Find min level of nodes in queue data
+    minLevel_ = (std::numeric_limits<int>::max)();
+    for (const auto& e : queueData_)
+        if (minLevel_ > e.second)
+            minLevel_ = e.second;
+
+    // Swap entries with min level to the end
+    auto p = std::partition(queueData_.begin(), queueData_.end(), [t = minLevel_] (const Entry& e) { return t != e.second; });
+
+    // Move min level values to next data
+    nextData_.reserve(std::distance(p, queueData_.end()));
+
+    for (auto it = p; it != queueData_.end(); ++it)
+        nextData_.push_back(it->first);
+
+    // Truncate moved entries
+    queueData_.resize(std::distance(queueData_.begin(), p));
+
+    return !nextData_.empty();
+}
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
+#endif // REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/ReactorNodes.h b/include/react/detail/graph/ReactorNodes.h
deleted file mode 100644
index c85cdcc0..00000000
--- a/include/react/detail/graph/ReactorNodes.h
+++ /dev/null
@@ -1,259 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_GRAPH_REACTORNODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_REACTORNODES_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <unordered_map>
-#include <utility>
-
-#include <boost/coroutine/all.hpp>
-
-#include "GraphBase.h"
-#include "EventNodes.h"
-#include "SignalNodes.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ReactorNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TContext
->
-class ReactorNode :
-    public NodeBase<D>
-{
-    using Engine = typename ReactorNode::Engine;
-
-public:
-    using CoroutineT = boost::coroutines::coroutine<NodeBase<D>*>;
-    using PullT = typename CoroutineT::pull_type;
-    using PushT = typename CoroutineT::push_type;
-    using TurnT = typename D::Engine::TurnT;
-
-    template <typename F>
-    ReactorNode(F&& func) :
-        ReactorNode::NodeBase( ),
-        func_( std::forward<F>(func) )
-    {
-        Engine::OnNodeCreate(*this);
-    }
-
-    ~ReactorNode()
-    {
-        Engine::OnNodeDestroy(*this);
-    }
-
-    void StartLoop()
-    {
-        mainLoop_ = PullT
-        (
-            [&] (PushT& out)
-            {
-                curOutPtr_ = &out;
-
-                TContext ctx( *this );
-
-                // Start the loop function.
-                // It will reach it its first Await at some point.
-                while (true)
-                {
-                    func_(ctx);
-                }
-            }
-        );
-
-        // First blocking event is not initiated by Tick() but after loop creation.
-        NodeBase<D>* p = mainLoop_.get();
-        doAttach(p);
-
-        ++depCount_;
-    }
-
-    virtual const char* GetNodeType() const override { return "ReactorNode"; }
-
-    virtual bool IsDynamicNode() const override { return true; }
-    virtual bool IsOutputNode() const override  { return true; }
-
-    virtual void Update(void* turnPtr) override
-    {
-        turnPtr_ = reinterpret_cast<TurnT*>(turnPtr);
-
-        mainLoop_();
-
-        NodeBase<D>* p = mainLoop_.get();
-
-        if (p != nullptr)
-        {
-            doDynAttach(p);
-        }
-        else
-        {
-            offsets_.clear();
-        }
-        
-        turnPtr_ = nullptr;
-    }
-
-    virtual int DependencyCount() const override
-    {
-        return depCount_;
-    }
-
-    template <typename E>
-    E& Await(const std::shared_ptr<EventStreamNode<D,E>>& events)
-    {
-        // First attach to target event node
-        (*curOutPtr_)(events.get());
-
-        while (! checkEvent(events))
-            (*curOutPtr_)(nullptr);
-
-        doDynDetach(events.get());
-
-        auto index = offsets_[reinterpret_cast<uintptr_t>(events.get())]++;
-        return events->Events()[index];
-    }
-
-    template <typename E, typename F>
-    void RepeatUntil(const std::shared_ptr<EventStreamNode<D,E>>& eventsPtr, const F& func)
-    {
-        // First attach to target event node
-        if (turnPtr_ != nullptr)
-        {
-            (*curOutPtr_)(eventsPtr.get());
-        }
-        else
-        {
-            // Non-dynamic attach in case first loop until is encountered before the loop was
-            // suspended for the first time.
-            doAttach(eventsPtr.get());
-        }
-
-        // Don't enter loop if event already present
-        if (! checkEvent(eventsPtr))
-        {
-            auto* parentOutPtr = curOutPtr_;
-
-            // Create and start loop
-            PullT nestedLoop_
-            {
-                [&] (PushT& out)
-                {
-                    curOutPtr_ = &out;
-                    while (true)
-                        func();
-                }
-            };
-
-            // First suspend from initial loop run
-            (*parentOutPtr)(nestedLoop_.get());
-
-            // Further iterations
-            while (! checkEvent(eventsPtr))
-            {
-                // Advance loop, forward blocking event to parent, and suspend
-                nestedLoop_(); 
-                (*parentOutPtr)(nestedLoop_.get());
-            }
-
-            curOutPtr_ = parentOutPtr;
-        }
-
-        // Detach when this function is exited
-        if (turnPtr_ != nullptr)
-            Engine::OnDynamicNodeDetach(*this, *eventsPtr, *turnPtr_);
-        else
-            Engine::OnNodeDetach(*this, *eventsPtr);
-
-        --depCount_;
-    }
-
-    template <typename S>
-    const S& Get(const std::shared_ptr<SignalNode<D,S>>& sigPtr)
-    {
-        // Do dynamic attach followed by attach if Get() happens during a turn.
-        if (turnPtr_ != nullptr)
-        {
-            // Request attach
-            (*curOutPtr_)(sigPtr.get());
-
-            doDynDetach(sigPtr.get());
-        }
-
-        return sigPtr->ValueRef();
-    }
-
-private:
-    template <typename E>
-    bool checkEvent(const std::shared_ptr<EventStreamNode<D,E>>& events)
-    {
-        if (turnPtr_ == nullptr)
-            return false;
-
-        events->SetCurrentTurn(*turnPtr_);
-
-        auto index = reinterpret_cast<uintptr_t>(events.get());
-        return offsets_[index] < events->Events().size();
-    }
-
-    void doAttach(NodeBase<D>* nodePtr)
-    {
-        assert(nodePtr != nullptr);
-        assert(turnPtr_ == nullptr);
-        Engine::OnNodeAttach(*this, *nodePtr);
-        ++depCount_;
-    }
-
-    void doDetach(NodeBase<D>* nodePtr)
-    {
-        assert(nodePtr != nullptr);
-        assert(turnPtr_ == nullptr);
-        Engine::OnNodeDetach(*this, *nodePtr);
-        --depCount_;
-    }
-
-    void doDynAttach(NodeBase<D>* nodePtr)
-    {
-        assert(nodePtr != nullptr);
-        assert(turnPtr_ != nullptr);
-        Engine::OnDynamicNodeAttach(*this, *nodePtr, *turnPtr_);
-        ++depCount_;
-    }
-
-    void doDynDetach(NodeBase<D>* nodePtr)
-    {
-        assert(nodePtr != nullptr);
-        assert(turnPtr_ != nullptr);
-        Engine::OnDynamicNodeDetach(*this, *nodePtr, *turnPtr_);
-        --depCount_;
-    }
-
-    std::function<void(TContext)>    func_;
-
-    PullT   mainLoop_;
-    TurnT*  turnPtr_;
-
-    PushT*  curOutPtr_ = nullptr;
-
-    uint    depCount_ = 0;
-
-    std::unordered_map<std::uintptr_t, size_t>    offsets_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_GRAPH_REACTORNODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 8f9424dc..b926ffa1 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -28,307 +28,202 @@ bool Equals(const L& lhs, const R& rhs);
 /// SignalNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class SignalNode : public ObservableNode
+class SignalNode : public NodeBase
 {
 public:
-    SignalNode() = default;
+    SignalNode(SignalNode&&) = default;
+    SignalNode& operator=(SignalNode&&) = default;
+
+    SignalNode(const SignalNode&) = delete;
+    SignalNode& operator=(const SignalNode&) = delete;
 
     template <typename U>
-    explicit SignalNode(U&& value) :
-        SignalNode::ObservableNode( ),
+    SignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& value) :
+        SignalNode::NodeBase( graphPtr ),
         value_( std::forward<T>(value) )
-    {}
+        { }
 
-    const S& ValueRef() const
-    {
-        return value_;
-    }
+    T& Value()
+        { return value_; }
 
-protected:
-    S value_;
-};
+    const T& Value() const
+        { return value_; }
 
-template <typename S>
-using SignalNodePtrT = std::shared_ptr<SignalNode<S>>;
+private:
+    T value_;
+};
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class VarNode :
-    public SignalNode<S>,
-    public IInputNode
+template <typename T>
+class VarSignalNode : public SignalNode<T>
 {
-    using Engine = typename VarNode::Engine;
-
 public:
     template <typename T>
-    VarNode(T&& value) :
-        VarNode::SignalNode( std::forward<T>(value) ),
+    VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& value) :
+        VarSignalNode::SignalNode( graphPtr, std::forward<T>(value) ),
         newValue_( value )
-    {
-        Engine::OnNodeCreate(*this);
-    }
+        { this->RegisterMe(); }
 
-    ~VarNode()
-    {
-        Engine::OnNodeDestroy(*this);
-    }
+    ~VarSignalNode()
+        { this->UnregisterMe(); }
 
-    virtual const char* GetNodeType() const override        { return "VarNode"; }
-    virtual bool        IsInputNode() const override        { return true; }
-    virtual int         DependencyCount() const override    { return 0; }
+    virtual const char* GetNodeType() const override
+        { return "VarSignal"; }
 
-    virtual void Update(void* turnPtr) override
-    {
-        REACT_ASSERT(false, "Ticked VarNode\n");
-    }
-
-    template <typename V>
-    void AddInput(V&& newValue)
-    {
-        newValue_ = std::forward<V>(newValue);
+    virtual bool IsInputNode() const override
+        { return true; }
 
-        isInputAdded_ = true;
-
-        // isInputAdded_ takes precedences over isInputModified_
-        // the only difference between the two is that isInputModified_ doesn't/can't compare
-        isInputModified_ = false;
-    }
+    virtual int GetDependencyCount() const override
+        { return 0; }
 
-    // This is signal-specific
-    template <typename F>
-    void ModifyInput(F& func)
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        // There hasn't been any Set(...) input yet, modify.
-        if (! isInputAdded_)
-        {
-            func(this->value_);
-
-            isInputModified_ = true;
-        }
-        // There's a newValue, modify newValue instead.
-        // The modified newValue will handled like before, i.e. it'll be compared to value_
-        // in ApplyInput
-        else
-        {
-            func(newValue_);            
-        }
-    }
-
-    virtual bool ApplyInput(void* turnPtr) override
-    {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
         if (isInputAdded_)
         {
             isInputAdded_ = false;
 
-            if (! Equals(this->value_, newValue_))
+            if (! Equals(this->Value(), newValue_))
             {
-                this->value_ = std::move(newValue_);
-                Engine::OnInputChange(*this, turn);
-                return true;
+                this->Value() = std::move(newValue_);
+                return UpdateResult::changed;
             }
             else
             {
-                return false;
+                return UpdateResult::unchanged;
             }
         }
         else if (isInputModified_)
         {            
             isInputModified_ = false;
-
-            Engine::OnInputChange(*this, turn);
-            return true;
+            return UpdateResult::changed;
         }
 
         else
         {
-            return false;
+            return UpdateResult::unchanged;
         }
     }
 
-private:
-    S       newValue_;
-    bool    isInputAdded_ = false;
-    bool    isInputModified_ = false;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// FunctionOp
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename S,
-    typename F,
-    typename ... TDeps
->
-class FunctionOp : public ReactiveOpBase<TDeps...>
-{
-public:
-    template <typename FIn, typename ... TDepsIn>
-    FunctionOp(FIn&& func, TDepsIn&& ... deps) :
-        FunctionOp::ReactiveOpBase( DontMove(), std::forward<TDepsIn>(deps) ... ),
-        func_( std::forward<FIn>(func) )
-    {}
-
-    FunctionOp(FunctionOp&& other) :
-        FunctionOp::ReactiveOpBase( std::move(other) ),
-        func_( std::move(other.func_) )
-    {}
-
-    S Evaluate() 
+    template <typename U>
+    void SetValue(U&& newValue)
     {
-        return apply(EvalFunctor( func_ ), this->deps_);
+        newValue_ = std::forward<U>(newValue);
+
+        isInputAdded_ = true;
+
+        // isInputAdded_ takes precedences over isInputModified_
+        // the only difference between the two is that isInputModified_ doesn't/can't compare
+        isInputModified_ = false;
     }
 
-private:
-    // Eval
-    struct EvalFunctor
+    // This is signal-specific
+    template <typename F>
+    void ModifyValue(F&& func)
     {
-        EvalFunctor(F& f) : MyFunc( f )   {}
-
-        template <typename ... T>
-        S operator()(T&& ... args)
+        // There hasn't been any Set(...) input yet, modify.
+        if (! isInputAdded_)
         {
-            return MyFunc(eval(args) ...);
-        }
+            func(this->Value());
 
-        template <typename T>
-        static auto eval(T& op) -> decltype(op.Evaluate())
-        {
-            return op.Evaluate();
+            isInputModified_ = true;
         }
-
-        template <typename T>
-        static auto eval(const std::shared_ptr<T>& depPtr) -> decltype(depPtr->ValueRef())
+        // There's a newValue, modify newValue instead.
+        // The modified newValue will handled like before, i.e. it'll be compared to value_
+        // in ApplyInput
+        else
         {
-            return depPtr->ValueRef();
+            func(newValue_);            
         }
-
-        F& MyFunc;
-    };
+    }
 
 private:
-    F   func_;
+    T       newValue_;
+    bool    isInputAdded_ = false;
+    bool    isInputModified_ = false;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalOpNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename S,
-    typename TOp
->
-class SignalOpNode : public SignalNode<S>
+template <typename T, typename F, typename ... TDeps>
+class SignalFuncNode : public SignalNode<T>
 {
-    using Engine = typename SignalOpNode::Engine;
-
 public:
-    template <typename ... TArgs>
-    SignalOpNode(TArgs&& ... args) :
-        SignalOpNode::SignalNode( ),
-        op_( std::forward<TArgs>(args) ... )
+    template <typename U>
+    SignalFuncNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
+        SignalFuncNode::SignalNode( graphPtr, func(deps->Value() ...) ),
+        func_( std::forward<U>(func) ),
+        depHolder_( deps ... )
     {
-        this->value_ = op_.Evaluate();
-
-        Engine::OnNodeCreate(*this);
-        op_.template Attach<D>(*this);
+        this->RegisterMe();
+        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
-    ~SignalOpNode()
+    ~SignalFuncNode()
     {
-        if (!wasOpStolen_)
-            op_.template Detach<D>(*this);
-        Engine::OnNodeDestroy(*this);
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(deps->GetNodeId())); }, depHolder_);
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
-    {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(GetObjectId(*this), turn.Id()));
-        
+    virtual UpdateResult Update(TurnId turnId) override
+    {   
         bool changed = false;
 
-        {// timer
-            using TimerT = typename SignalOpNode::ScopedUpdateTimer;
-            TimerT scopedTimer( *this, 1 );
-
-            S newValue = op_.Evaluate();
-
-            if (! Equals(this->value_, newValue))
-            {
-                this->value_ = std::move(newValue);
-                changed = true;
-            }
-        }// ~timer
+        T newValue = apply([this] (const auto& ... deps) { return this->func_(deps->Value() ...); }, depHolder_);
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(GetObjectId(*this), turn.Id()));
+        if (! Equals(this->Value(), newValue))
+        {
+            this->Value() = std::move(newValue);
+            changed = true;
+        }
 
         if (changed)
-            Engine::OnNodePulse(*this, turn);
+            return UpdateResult::changed;
         else
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override        { return "SignalOpNode"; }
-    virtual int         DependencyCount() const override    { return TOp::dependency_count; }
+    virtual const char* GetNodeType() const override
+        { return "SignalFunc"; }
 
-    TOp StealOp()
-    {
-        REACT_ASSERT(wasOpStolen_ == false, "Op was already stolen.");
-        wasOpStolen_ = true;
-        op_.template Detach<D>(*this);
-        return std::move(op_);
-    }
+    virtual int GetDependencyCount() const override
+        { return sizeof...(TDeps); }
 
 private:
-    TOp     op_;
-    bool    wasOpStolen_ = false;
+    std::tuple<std::shared_ptr<SignalNode<TDeps>> ...> depHolder_;
+
+    F func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TOuter,
-    typename TInner
->
-class FlattenNode : public SignalNode<TInner>
+template <typename TOuter, typename TInner>
+class SignalFlattenNode : public SignalNode<TInner>
 {
-    using Engine = typename FlattenNode::Engine;
-
 public:
-    FlattenNode(const std::shared_ptr<SignalNode<D,TOuter>>& outer,
-                const std::shared_ptr<SignalNode<D,TInner>>& inner) :
-        FlattenNode::SignalNode( inner->ValueRef() ),
+    SignalFlattenNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<TOuter>>& outer, const std::shared_ptr<SignalNode<TInner>>& inner) :
+        SignalFlattenNode::SignalNode( graphPtr, inner->Value() ),
         outer_( outer ),
         inner_( inner )
     {
-        Engine::OnNodeCreate(*this);
-        Engine::OnNodeAttach(*this, *outer_);
-        Engine::OnNodeAttach(*this, *inner_);
+        this->RegisterMe();
+        this->AttachToMe(outer->GetNodeId());
+        this->AttachToMe(inner->GetNodeId());
     }
 
-    ~FlattenNode()
+    ~SignalFlattenNode()
     {
-        Engine::OnNodeDetach(*this, *inner_);
-        Engine::OnNodeDetach(*this, *outer_);
-        Engine::OnNodeDestroy(*this);
+        this->DetachFromMe(inner->GetNodeId());
+        this->DetachFromMe(outer->GetNodeId());
+        this->UnregisterMe();
     }
 
-    virtual void Update(void* turnPtr) override
+    virtual UpdateResult Update(TurnId turnId) override
     {
-        using TurnT = typename D::Engine::TurnT;
-        TurnT& turn = *reinterpret_cast<TurnT*>(turnPtr);
-
-        auto newInner = GetNodePtr(outer_->ValueRef());
+        auto newInner = GetNodePtr(outer_->Value());
 
         if (newInner != inner_)
         {
@@ -336,36 +231,35 @@ class FlattenNode : public SignalNode<TInner>
             auto oldInner = inner_;
             inner_ = newInner;
 
-            Engine::OnDynamicNodeDetach(*this, *oldInner, turn);
-            Engine::OnDynamicNodeAttach(*this, *newInner, turn);
+            this->DynamicDetachFromMe(oldInner->GetNodeId(), 0);
+            this->DynamicAttachToMe(newInner->GetNodeId(), 0);
 
-            return;
+            return UpdateResult::shifted;
         }
 
-        REACT_LOG(D::Log().template Append<NodeEvaluateBeginEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        REACT_LOG(D::Log().template Append<NodeEvaluateEndEvent>(
-            GetObjectId(*this), turn.Id()));
-
-        if (! Equals(this->value_, inner_->ValueRef()))
+        if (! Equals(this->Value(), inner_->Value()))
         {
-            this->value_ = inner_->ValueRef();
-            Engine::OnNodePulse(*this, turn);
+            this->Value() = inner_->Value();
+            return UpdateResult::changed;
         }
         else
         {
-            Engine::OnNodeIdlePulse(*this, turn);
+            return UpdateResult::unchanged;
         }
     }
 
-    virtual const char* GetNodeType() const override        { return "FlattenNode"; }
-    virtual bool        IsDynamicNode() const override      { return true; }
-    virtual int         DependencyCount() const override    { return 2; }
+    virtual const char* GetNodeType() const override
+        { return "SignalFlatten"; }
+
+    virtual bool IsDynamicNode() const override
+        { return true; }
+
+    virtual int GetDependencyCount() const override
+        { return 2; }
 
 private:
-    std::shared_ptr<SignalNode<TOuter>>   outer_;
-    std::shared_ptr<SignalNode<TInner>>   inner_;
+    std::shared_ptr<SignalNode<TOuter>> outer_;
+    std::shared_ptr<SignalNode<TInner>> inner_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/engine/PulsecountEngine.h b/include/react/engine/PulsecountEngine.h
index 95308f3c..78999c6f 100644
--- a/include/react/engine/PulsecountEngine.h
+++ b/include/react/engine/PulsecountEngine.h
@@ -9,6 +9,8 @@
 
 #pragma once
 
+#if 0
+
 #include "react/detail/Defs.h"
 
 #include <atomic>
@@ -144,4 +146,6 @@ struct NodeUpdateTimerEnabled<PulsecountEngine<parallel_propagation>> : std::tru
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_ENGINE_PULSECOUNTENGINE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_ENGINE_PULSECOUNTENGINE_H_INCLUDED
+
+#endif
\ No newline at end of file
diff --git a/include/react/engine/SubtreeEngine.h b/include/react/engine/SubtreeEngine.h
index cfda49d1..447c1184 100644
--- a/include/react/engine/SubtreeEngine.h
+++ b/include/react/engine/SubtreeEngine.h
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #ifndef REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
 #define REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
 
@@ -191,4 +193,6 @@ struct NodeUpdateTimerEnabled<SubtreeEngine<parallel_propagation>> : std::true_t
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
+
+#endif
\ No newline at end of file
diff --git a/include/react/engine/ToposortEngine.h b/include/react/engine/ToposortEngine.h
index 331ecd11..2575bbd9 100644
--- a/include/react/engine/ToposortEngine.h
+++ b/include/react/engine/ToposortEngine.h
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #ifndef REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
 #define REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
 
@@ -207,4 +209,6 @@ struct NodeUpdateTimerEnabled<ToposortEngine<parallel_propagation>> : std::true_
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
+
+#endif
\ No newline at end of file
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index f2e9c00c..0d380c1c 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -154,11 +154,12 @@
     </Lib>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="..\..\include\react\API.h" />
     <ClInclude Include="..\..\include\react\common\RefCounting.h" />
     <ClInclude Include="..\..\include\react\common\Timing.h" />
-    <ClInclude Include="..\..\include\react\detail\DomainBase.h" />
-    <ClInclude Include="..\..\include\react\detail\EventBase.h" />
     <ClInclude Include="..\..\include\react\detail\graph\ObserverNodes.h" />
+    <ClInclude Include="..\..\include\react\detail\graph\PropagationST.h" />
+    <ClInclude Include="..\..\include\react\detail\graph\PropagationMT.h" />
     <ClInclude Include="..\..\include\react\detail\ObserverBase.h" />
     <ClInclude Include="..\..\include\react\detail\ReactiveInput.h" />
     <ClInclude Include="..\..\include\react\detail\Defs.h" />
@@ -167,11 +168,8 @@
     <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h" />
     <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\IReactiveGroup.h" />
-    <ClInclude Include="..\..\include\react\detail\IReactiveNode.h" />
-    <ClInclude Include="..\..\include\react\detail\ReactiveBase.h" />
-    <ClInclude Include="..\..\include\react\detail\SignalBase.h" />
-    <ClInclude Include="..\..\include\react\Domain.h" />
+    <ClInclude Include="..\..\include\react\detail\IReactiveGraph.h" />
+    <ClInclude Include="..\..\include\react\Group.h" />
     <ClInclude Include="..\..\include\react\engine\PulsecountEngine.h" />
     <ClInclude Include="..\..\include\react\engine\SubtreeEngine.h" />
     <ClInclude Include="..\..\include\react\engine\ToposortEngine.h" />
@@ -181,21 +179,16 @@
     <ClInclude Include="..\..\include\react\common\TopoQueue.h" />
     <ClInclude Include="..\..\include\react\common\Types.h" />
     <ClInclude Include="..\..\include\react\common\Util.h" />
-    <ClInclude Include="..\..\include\react\logging\EventLog.h" />
-    <ClInclude Include="..\..\include\react\logging\EventRecords.h" />
-    <ClInclude Include="..\..\include\react\logging\Logging.h" />
     <ClInclude Include="..\..\include\react\Algorithm.h" />
     <ClInclude Include="..\..\include\react\Event.h" />
     <ClInclude Include="..\..\include\react\Observer.h" />
     <ClInclude Include="..\..\include\react\Signal.h" />
-    <ClInclude Include="..\..\include\react\TypeTraits.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="..\..\src\debug.cpp" />
     <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp" />
     <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp" />
     <ClCompile Include="..\..\src\engine\ToposortEngine.cpp" />
-    <ClCompile Include="..\..\src\logging\EventLog.cpp" />
-    <ClCompile Include="..\..\src\logging\EventRecords.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index 2b7a6008..1174c9b1 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -25,15 +25,9 @@
     <Filter Include="Header Files\common">
       <UniqueIdentifier>{11a75126-8bfd-4693-be4b-4e06ab73450c}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\logging">
-      <UniqueIdentifier>{f58215db-3a12-432a-a4c1-e24a90df70a9}</UniqueIdentifier>
-    </Filter>
     <Filter Include="Source Files\engine">
       <UniqueIdentifier>{3f444875-ab1a-4bbd-99eb-7018c930098a}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\logging">
-      <UniqueIdentifier>{22da08e3-fb85-4fed-9fbc-8944ef866ccc}</UniqueIdentifier>
-    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\include\react\common\Containers.h">
@@ -51,9 +45,6 @@
     <ClInclude Include="..\..\include\react\common\Util.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Signal.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\common\Concurrency.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
@@ -66,30 +57,12 @@
     <ClInclude Include="..\..\include\react\detail\EngineBase.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\IReactiveNode.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\ReactiveBase.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
     <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\logging\EventLog.h">
-      <Filter>Header Files\logging</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\logging\EventRecords.h">
-      <Filter>Header Files\logging</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\logging\Logging.h">
-      <Filter>Header Files\logging</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\Algorithm.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\ReactiveInput.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
@@ -102,30 +75,12 @@
     <ClInclude Include="..\..\include\react\detail\graph\ObserverNodes.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\SignalBase.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\Observer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\EventBase.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\Event.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
     <ClInclude Include="..\..\include\react\engine\ToposortEngine.h">
       <Filter>Header Files\engine</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\TypeTraits.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\Domain.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\common\Timing.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
@@ -135,20 +90,35 @@
     <ClInclude Include="..\..\include\react\common\RefCounting.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\DomainBase.h">
+    <ClInclude Include="..\..\include\react\detail\IReactiveGraph.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\IReactiveGroup.h">
-      <Filter>Header Files\detail</Filter>
+    <ClInclude Include="..\..\include\react\detail\graph\PropagationST.h">
+      <Filter>Header Files\detail\graph</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\detail\graph\PropagationMT.h">
+      <Filter>Header Files\detail\graph</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\Algorithm.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\Event.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\Observer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\Signal.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\API.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\Group.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\src\logging\EventLog.cpp">
-      <Filter>Source Files\logging</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\src\logging\EventRecords.cpp">
-      <Filter>Source Files\logging</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp">
       <Filter>Source Files\engine</Filter>
     </ClCompile>
@@ -158,5 +128,8 @@
     <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp">
       <Filter>Source Files\engine</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\debug.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/engine/PulsecountEngine.cpp b/src/engine/PulsecountEngine.cpp
index 5fa3a844..0be62ba6 100644
--- a/src/engine/PulsecountEngine.cpp
+++ b/src/engine/PulsecountEngine.cpp
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #include "react/engine/PulsecountEngine.h"
 
 #include <cstdint>
@@ -281,4 +283,6 @@ void EngineBase::OnDynamicNodeDetach(Node& node, Node& parent, Turn& turn)
 }// ~parent.ShiftMutex (write)
 
 } // ~namespace pulsecount
-/****************************************/ REACT_IMPL_END /***************************************/
\ No newline at end of file
+/****************************************/ REACT_IMPL_END /***************************************/
+
+#endif
\ No newline at end of file
diff --git a/src/engine/SubtreeEngine.cpp b/src/engine/SubtreeEngine.cpp
index c71d6e0f..8584fcc2 100644
--- a/src/engine/SubtreeEngine.cpp
+++ b/src/engine/SubtreeEngine.cpp
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #include "react/engine/SubtreeEngine.h"
 
 #include <cstdint>
@@ -341,4 +343,6 @@ void EngineBase::invalidateSuccessors(Node& node)
 }
 
 } // ~namespace subtree
-/****************************************/ REACT_IMPL_END /***************************************/
\ No newline at end of file
+/****************************************/ REACT_IMPL_END /***************************************/
+
+#endif
\ No newline at end of file
diff --git a/src/engine/ToposortEngine.cpp b/src/engine/ToposortEngine.cpp
index 54612191..b8db5f67 100644
--- a/src/engine/ToposortEngine.cpp
+++ b/src/engine/ToposortEngine.cpp
@@ -4,6 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#if 0
+
 #include "react/engine/ToposortEngine.h"
 #include "tbb/parallel_for.h"
 
@@ -216,4 +218,6 @@ void ParEngineBase::invalidateSuccessors(ParNode& node)
 }
 
 } // ~namespace toposort
-/****************************************/ REACT_IMPL_END /***************************************/
\ No newline at end of file
+/****************************************/ REACT_IMPL_END /***************************************/
+
+#endif
\ No newline at end of file

From 54d1f02576b09229cf9f2cb7e66f912e197cdf27 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 5 Aug 2016 03:18:28 +0200
Subject: [PATCH 31/75] Redesign progress.

---
 include/react/Algorithm.h                   |  51 ++--
 include/react/Event.h                       | 270 +++++++-------------
 include/react/Signal.h                      | 105 ++++----
 include/react/detail/ObserverBase.h         |   2 -
 include/react/detail/graph/AlgorithmNodes.h |   4 +-
 include/react/detail/graph/EventNodes.h     |  26 +-
 6 files changed, 189 insertions(+), 269 deletions(-)

diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index e2a1f3a9..d41d0fef 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -23,41 +23,34 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Hold - Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename U>
-auto Hold(const Events<T>& events, U&& init) -> Signal<T>
+template <typename T, typename E>
+auto Hold(T&& initialValue, const EventBase<E>& events) -> Signal<E, unique>
 {
     using REACT_IMPL::HoldNode;
+    using REACT_IMPL::PrivateNodeInterface;
 
-    return Signal<T>(
-        std::make_shared<HoldNode<T>>(
-            std::forward<V>(init), GetNodePtr(events)));
+    return Signal<E, unique>( std::make_shared<HoldNode<T>>(
+        PrivateNodeInterface::GraphPtr(events), std::forward<U>(initialValue), PrivateNodeInterface::NodePtr(events)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Monitor - Emits value changes of target signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-auto Monitor(const Signal<T>& target) -> Events<T>
+template <typename S>
+auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
 {
     using REACT_IMPL::MonitorNode;
+    using REACT_IMPL::PrivateNodeInterface;
 
-    return Events<T>(
-        std::make_shared<MonitorNode<T>>(
-            GetNodePtr(target)));
+    return Event<S, unique>( std::make_shared<MonitorNode<T>>(
+        PrivateNodeInterface::GraphPtr(signal), PrivateNodeInterface::NodePtr(signal)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename S,
-    typename E,
-    typename V,
-    typename F,
-    
->
-auto Iterate(const Events<E>& events, V&& init, F&& func) -> Signal<S>
+template <typename S, typename T, typename F, typename E>
+auto Iterate(T&& init, F&& func, const Events<E>& events) -> Signal<S, unique>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
@@ -178,28 +171,28 @@ auto Iterate(const Events<E>& events, V&& init, const SignalPack<TDepValues...>&
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Snapshot(const Events<E>& trigger, const Signal<S>& target) -> Signal<S>
+auto Snapshot(const Signal<S>& signal, const Events<E>& trigger) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
+    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateNodeInterface;
 
-    return Signal<S>(
-        std::make_shared<SnapshotNode<S,E>>(
-            GetNodePtr(target), GetNodePtr(trigger)));
+    return Events<S, unique>( std::make_shared<SnapshotNode<S, E>>(
+        GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
 }
 
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Pulse - Emits value of target signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Pulse(const Events<E>& trigger, const Signal<S>& target) -> Events<S>
+auto Pulse(const Signal<S>& signal, const Events<E>& trigger) -> Events<S>
 {
     using REACT_IMPL::PulseNode;
+    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateNodeInterface;
 
-    return Events<S>(
-        std::make_shared<PulseNode<S,E>>(
-            GetNodePtr(target), GetNodePtr(trigger)));
+    return Events<S, unique>( std::make_shared<PulseNode<S, E>>(
+        GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Event.h b/include/react/Event.h
index 5af37093..e244ec46 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -25,11 +25,11 @@
 /// Events
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-template <typename T = Token>
+template <typename E = Token>
 class EventBase
 {
 private:
-    using NodeType = REACT_IMPL::EventStreamNode<T>;
+    using NodeType = REACT_IMPL::EventStreamNode<E>;
 
 public:
     EventBase() = default;
@@ -69,16 +69,26 @@ class EventBase
     auto NodePtr() const -> const std::shared_ptr<NodeType>&
         { return nodePtr_; }
 
-    template <typename FIn, typename TIn>
-    auto CreateProcessingNode(FIn&& func, const EventBase<TIn>& dep) -> decltype(auto)
+    template <typename F, typename T>
+    auto CreateProcessingNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
     {
-        using F = typename std::decay<FIn>::type;
-        using ProcessingNodeType = REACT_IMPL::EventProcessingNode<T, TIn, F>;
+        using ProcessingNodeType = REACT_IMPL::EventProcessingNode<E, T, typename std::decay<F>::type>;
 
         return std::make_shared<ProcessingNodeType>(
             REACT_IMPL::PrivateNodeInterface::GraphPtr(dep),
-            REACT_IMPL::PrivateNodeInterface::NodePtr(dep),
-            std::forward<F>(func));
+            std::forward<F>(func),
+            REACT_IMPL::PrivateNodeInterface::NodePtr(dep));
+    }
+
+    template <typename F, typename T, typename ... Us>
+    auto CreateSyncedProcessingNode(F&& func, const EventBase<T>& dep, const SignalBase<Us> ... syncs) -> decltype(auto)
+    {
+        using SyncedProcessingNodeType = REACT_IMPL::SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>;
+
+        return std::make_shared<SyncedProcessingNodeType>(
+            REACT_IMPL::GetCheckedGraphPtr(dep, syncs ...),
+            std::forward<F>(func),
+            REACT_IMPL::PrivateNodeInterface::NodePtr(dep), REACT_IMPL::PrivateNodeInterface::NodePtr(syncs) ...);
     }
 
 private:
@@ -90,11 +100,11 @@ class EventBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSource
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T = Token>
-class EventSourceBase : public EventBase<T>
+template <typename E = Token>
+class EventSourceBase : public EventBase<E>
 {
 private:
-    using NodeType = REACT_IMPL::EventSourceNode<T>;
+    using NodeType = REACT_IMPL::EventSourceNode<E>;
 
 public:
     using EventBase::EventBase;
@@ -112,25 +122,25 @@ class EventSourceBase : public EventBase<T>
         EventSourceBase::EventBase( std::make_shared<NodeType>(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
     
-    void Emit(const T& value)
+    void Emit(const E& value)
         { EmitValue(value); }
 
-    void Emit(T&& value)
+    void Emit(E&& value)
         { EmitValue(std::move(value)); }
 
-    template <typename U = T, typename = typename std::enable_if<std::is_same<U,Token>::value>::type>
+    template <typename T = E, typename = typename std::enable_if<std::is_same<T,Token>::value>::type>
     void Emit()
         { EmitValue(Token::value); }
 
-    EventSourceBase& operator<<(const T& value)
+    EventSourceBase& operator<<(const E& value)
         { EmitValue(e); return *this; }
 
-    EventSourceBase& operator<<(T&& value)
+    EventSourceBase& operator<<(E&& value)
         { EmitValue(std::move(value)); return *this; }
 
 private:
-    template <typename U>
-    void EmitValue(U&& value)
+    template <typename T>
+    void EmitValue(T&& value)
     {
         using REACT_IMPL::NodeId;
         using REACT_IMPL::IReactiveGraph;
@@ -139,20 +149,20 @@ class EventSourceBase : public EventBase<T>
 
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = NodePtr()->GraphPtr();
-        graphPtr->AddInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<U>(value)); });
+        graphPtr->AddInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<T>(value)); });
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Event
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class Event<T, unique> : public EventBase<T>
+template <typename E>
+class Event<E, unique> : public EventBase<E>
 {
 public:
     using EventBase::EventBase;
 
-    using ValueType = T;
+    using ValueType = E;
 
     Event() = delete;
 
@@ -162,19 +172,24 @@ class Event<T, unique> : public EventBase<T>
     Event(Event&&) = default;
     Event& operator=(Event&&) = default;
 
-    template <typename F, typename U>
-    Event(F&& func, const EventBase<U>& dep) :
+    template <typename F, typename T>
+    Event(F&& func, const EventBase<T>& dep) :
         Event::EventBase( CreateProcessingNode(std::forward<F>(func), dep) )
         { }
+
+    template <typename F, typename T, typename ... Us>
+    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us> ... signals) :
+        Event::EventBase( CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        { }
 };
 
-template <typename T>
-class Event<T, shared> : public EventBase<T>
+template <typename E>
+class Event<E, shared> : public EventBase<E>
 {
 public:
     using EventBase::EventBase;
 
-    using ValueType = T;
+    using ValueType = E;
 
     Event() = delete;
 
@@ -184,29 +199,34 @@ class Event<T, shared> : public EventBase<T>
     Event(Event&&) = default;
     Event& operator=(Event&&) = default;
 
-    Event(Event<T, unique>&& other) :
+    Event(Event<E, unique>&& other) :
         Event::EventBase( std::move(other) )
         { }
 
-    Event& operator=(Event<T, unique>&& other)
+    Event& operator=(Event<E, unique>&& other)
         { Event::EventBase::operator=(std::move(other)); return *this; }
 
-    template <typename F, typename U>
-    Event(F&& func, const EventBase<U>& dep) :
+    template <typename F, typename T>
+    Event(F&& func, const EventBase<T>& dep) :
         Event::EventBase( CreateProcessingNode(std::forward<F>(func), dep) )
         { }
+
+    template <typename F, typename T, typename ... Us>
+    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us> ... signals) :
+        Event::EventBase( SyncedCreateProcessingNode(std::forward<F>(func), dep, signals ...) )
+        { }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSource
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class EventSource<T, unique> : public EventSourceBase<T>
+template <typename E>
+class EventSource<E, unique> : public EventSourceBase<E>
 {
 public:
     using EventSourceBase::EventSourceBase;
 
-    using ValueType = T;
+    using ValueType = E;
 
     EventSource() = delete;
 
@@ -217,13 +237,13 @@ class EventSource<T, unique> : public EventSourceBase<T>
     EventSource& operator=(EventSource&&) = default;
 };
 
-template <typename T>
-class EventSource<T, shared> : public EventSourceBase<T>
+template <typename E>
+class EventSource<E, shared> : public EventSourceBase<E>
 {
 public:
     using EventSourceBase::EventSourceBase;
 
-    using ValueType = T;
+    using ValueType = E;
 
     EventSource() = delete;
 
@@ -233,11 +253,11 @@ class EventSource<T, shared> : public EventSourceBase<T>
     EventSource(EventSource&&) = default;
     EventSource& operator=(EventSource&&) = default;
 
-    EventSource(EventSource<T, unique>&& other) :
+    EventSource(EventSource<E, unique>&& other) :
         EventSource::EventSourceBase( std::move(other) )
         { }
 
-    EventSource& operator=(EventSource<T, unique>&& other)
+    EventSource& operator=(EventSource<E, unique>&& other)
         { EventSource::EventSourceBase::operator=(std::move(other)); return *this; }
 };
 
@@ -251,7 +271,7 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
     using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
 
-    static_assert(sizeof...(Us) > 0, "Merge: 2+ arguments are required.");
+    static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
 
     // If supplied, use merge type, otherwise default to common type.
     using E = typename std::conditional<
@@ -268,174 +288,80 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename F, typename T>
-auto Filter(F&& pred, const EventBase<T>& dep) -> Event<T, unique>
+template <typename F, typename E>
+auto Filter(F&& pred, const EventBase<E>& dep) -> Event<E, unique>
 {
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<T> out)
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
         { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
 
-    return Event<T, unique>(std::move(filterFunc), dep);
+    return Event<E, unique>(std::move(filterFunc), dep);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Transform
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F, typename U>
-auto Transform(F&& op, const EventBase<U>& dep) -> Event<T, unique>
+template <typename F, typename E, typename ... Ts>
+auto Filter(F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals) -> Event<E, unique>
 {
-    auto transformFunc = [capturedPred = std::forward<F>(op)] (EventRange<U> inRange, EventSink<T> out)
-        { std::transform(inRange.begin(), inRange.end(), out, pred); };
-
-    return Event<T, unique>(std::move(transformFunc), dep);
-}
-
-#if 0
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Filter - Synced
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename E,
-    typename FIn,
-    typename ... TDepValues
->
-auto Filter(const Events<E>& source, const SignalPack<TDepValues...>& depPack, FIn&& func) -> Events<E>
-{
-    using REACT_IMPL::SyncedEventFilterNode;
-
-    using F = typename std::decay<FIn>::type;
-
-    struct NodeBuilder_
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
     {
-        NodeBuilder_(const Events<E>& source, FIn&& func) :
-            MySource( source ),
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Events<E>
-        {
-            return Events<E>(
-                std::make_shared<SyncedEventFilterNode<D,E,F,TDepValues ...>>(
-                     GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
-        }
-
-        const Events<E>&      MySource;
-        FIn                     MyFunc;
+        for (const auto& v : inRange)
+            if (capturedPred(v, values ...))
+                *out++ = v;
     };
 
-    return REACT_IMPL::apply(
-        NodeBuilder_( source, std::forward<FIn>(func) ),
-        depPack.Data);
+    return Event<E, unique>(std::move(filterFunc), dep, signals ...);
 }
 
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Transform - Synced
+/// Transform
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TIn,
-    typename FIn,
-    typename ... TDepValues,
-    typename TOut = typename std::result_of<FIn(TIn,TDepValues...)>::type
->
-auto Transform(const Events<TIn>& source, FIn&& func, const Signal<TDepValues>& ... deps) -> Events<TOut>
+template <typename E, typename F, typename T>
+auto Transform(F&& op, const EventBase<T>& dep) -> Event<E, unique>
 {
-    using REACT_IMPL::SyncedEventTransformNode;
+    auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
+        { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
 
-    using F = typename std::decay<FIn>::type;
-
-    struct NodeBuilder_
-    {
-        NodeBuilder_(const Events<TIn>& source, FIn&& func) :
-            MySource( source ),
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Events<TOut>
-        {
-            return Events<TOut>(
-                std::make_shared<SyncedEventTransformNode<D,TIn,TOut,F,TDepValues ...>>(
-                     GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
-        }
-
-        const Events<TIn>&    MySource;
-        FIn                     MyFunc;
-    };
-
-    return REACT_IMPL::apply(
-        NodeBuilder_( source, std::forward<FIn>(func) ),
-        depPack.Data);
+    return Event<E, unique>(std::move(transformFunc), dep);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Process - Synced
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TOut,
-    typename TIn,
-    typename FIn,
-    typename ... TDepValues
->
-auto Process(const Events<TIn>& source, const SignalPack<D,TDepValues...>& depPack, FIn&& func) -> Events<TOut>
+template <typename E, typename F, typename T, typename ... Us>
+auto Transform(F&& op, const EventBase<T>& dep, const SignalBase<Us>& ... signals) -> Event<E, unique>
 {
-    using REACT_IMPL::SyncedEventProcessingNode;
-
-    using F = typename std::decay<FIn>::type;
-
-    struct NodeBuilder_
+    auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
     {
-        NodeBuilder_(const Events<TIn>& source, FIn&& func) :
-            MySource( source ),
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Events<TOut>
-        {
-            return Events<TOut>(
-                std::make_shared<SyncedEventProcessingNode<D,TIn,TOut,F,TDepValues ...>>(
-                     GetNodePtr(MySource), std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
-        }
-
-        const Events<TIn>&    MySource;
-        FIn                     MyFunc;
+        for (const auto& v : inRange)
+            *out++ = capturedPred(v, values ...);
     };
 
-    return REACT_IMPL::apply(
-        NodeBuilder_( source, std::forward<FIn>(func) ),
-        depPack.Data);
+    return Event<E, unique>(std::move(transformFunc), dep, signals ...);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TInnerValue>
+/*template <typename TInnerValue>
 auto Flatten(const Signal<Events<TInnerValue>>& outer) -> Events<TInnerValue>
 {
     return Events<TInnerValue>(
         std::make_shared<REACT_IMPL::EventFlattenNode<Events<TInnerValue>, TInnerValue>>(
             GetNodePtr(outer), GetNodePtr(outer.Value())));
-}
+}*/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename ... TArgs>
-auto Join(const Events<TArgs>& ... args) -> Events<std::tuple<TArgs ...>>
+template <typename ... Ts>
+auto Join(const EventBase<Ts>& ... deps) -> Event<std::tuple<Ts ...>, unique>
 {
     using REACT_IMPL::EventJoinNode;
+    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateNodeInterface;
+
+    static_assert(sizeof...(Ts) > 1, "Join requires at least 2 inputs.");
 
-    static_assert(sizeof...(TArgs) > 1, "Join: 2+ arguments are required.");
+    // If supplied, use merge type, otherwise default to common type.
+    const auto& graphPtr = GetCheckedGraphPtr(deps ...);
 
-    return Events< std::tuple<TArgs ...>>(
-        std::make_shared<EventJoinNode<TArgs...>>(
-            GetNodePtr(args) ...));
+    return Event<std::tuple<Ts ...>, unique>(
+        std::make_shared<EventJoinNode<Ts ...>>(graphPtr, PrivateNodeInterface::NodePtr(deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -443,7 +369,7 @@ auto Join(const Events<TArgs>& ... args) -> Events<std::tuple<TArgs ...>>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 enum class Token { value };
 
-struct Tokenizer
+/*struct Tokenizer
 {
     template <typename T>
     Token operator()(const T&) const { return Token::value; }
@@ -453,9 +379,7 @@ template <typename T>
 auto Tokenize(T&& source) -> decltype(auto)
 {
     return Transform(source, Tokenizer{ });
-}
-
-#endif
+}*/
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/Signal.h b/include/react/Signal.h
index ea60ce3a..e8222bf3 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -29,11 +29,11 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
+template <typename S>
 class SignalBase
 {
 private:
-    using NodeType = REACT_IMPL::SignalNode<T>;
+    using NodeType = REACT_IMPL::SignalNode<S>;
 
 public:
     SignalBase() = default;
@@ -46,12 +46,12 @@ class SignalBase
 
     ~SignalBase() = default;
 
-    // Internal node ctor
+    // Private node ctor
     explicit SignalBase(std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
         { }
 
-    const T& Value() const
+    const S& Value() const
         { return nodePtr_->Value(); }
 
 protected:
@@ -61,16 +61,18 @@ class SignalBase
     auto NodePtr() const -> const std::shared_ptr<NodeType>&
         { return nodePtr_; }
 
-    template <typename FIn, typename U1, typename ... Us>
-    auto CreateFuncNode(FIn&& func, const SignalBase<U1>& dep1, const SignalBase<Us>& ... deps) -> decltype(auto)
+    template <typename F, typename T1, typename ... Ts>
+    auto CreateFuncNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-        using F = typename std::decay<FIn>::type;
-        using FuncNodeType = REACT_IMPL::SignalFuncNode<T, F, U1, Us ...>;
+        using REACT_IMPL::GetCheckedGraphPtr;
+        using REACT_IMPL::PrivateNodeInterface;
+
+        using FuncNodeType = REACT_IMPL::SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<FuncNodeType>(
-            REACT_IMPL::GetCheckedGraphPtr(dep1, deps ...),
-            std::forward<FIn>(func),
-            REACT_IMPL::PrivateNodeInterface::NodePtr(dep1), REACT_IMPL::PrivateNodeInterface::NodePtr(deps) ...);
+            GetCheckedGraphPtr(dep1, deps ...),
+            std::forward<F>(func),
+            PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...);
     }
 
 private:
@@ -82,8 +84,8 @@ class SignalBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarSignalBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class VarSignalBase : public SignalBase<T>
+template <typename S>
+class VarSignalBase : public SignalBase<S>
 {
 public:
     using SignalBase::SignalBase;
@@ -96,16 +98,16 @@ class VarSignalBase : public SignalBase<T>
     VarSignalBase(VarSignalBase&&) = default;
     VarSignalBase& operator=(VarSignalBase&&) = default;
 
-    void Set(const T& newValue)
+    void Set(const S& newValue)
         { SetValue(newValue); }
 
-    void Set(T&& newValue)
+    void Set(S&& newValue)
         { SetValue(std::move(newValue)); }
 
-    void operator<<=(const T& newValue)
+    void operator<<=(const S& newValue)
         { SetValue(newValue); }
 
-    void operator<<=(T&& newValue)
+    void operator<<=(S&& newValue)
         { SetValue(std::move(newValue)); }
 
     template <typename F>
@@ -113,26 +115,29 @@ class VarSignalBase : public SignalBase<T>
         { ModifyValue(func); }
 
 protected:
-    template <typename U, typename TGroup>
-    auto CreateVarNode(U&& value, const TGroup& group) -> decltype(auto)
+    template <typename T, typename TGroup>
+    auto CreateVarNode(T&& value, const TGroup& group) -> decltype(auto)
     {
-        using VarNodeType = REACT_IMPL::VarSignalNode<T>;
-        return std::make_shared<VarNodeType>(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<U>(value));
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+
+        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
+
+        return std::make_shared<VarNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value));
     }
 
 private:
-    template <typename U>
-    void SetValue(U&& newValue)
+    template <typename T>
+    void SetValue(T&& newValue)
     {
         using REACT_IMPL::NodeId;
         using REACT_IMPL::IReactiveGraph;
-        using VarNodeType = REACT_IMPL::VarSignalNode<T>;
+        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
 
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = NodePtr()->GraphPtr();
-        graphPtr->AddInput(nodeId, [castedPtr, &newValue] { castedPtr->SetValue(std::forward<U>(newValue)); });
+        graphPtr->AddInput(nodeId, [castedPtr, &newValue] { castedPtr->SetValue(std::forward<T>(newValue)); });
     }
 
     template <typename F>
@@ -140,7 +145,7 @@ class VarSignalBase : public SignalBase<T>
     {
         using REACT_IMPL::NodeId;
         using REACT_IMPL::IReactiveGraph;
-        using VarNodeType = REACT_IMPL::VarSignalNode<T>;
+        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
         
@@ -153,13 +158,13 @@ class VarSignalBase : public SignalBase<T>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class Signal<T, unique> : public SignalBase<T>
+template <typename S>
+class Signal<S, unique> : public SignalBase<S>
 {
 public:
     using SignalBase::SignalBase;
 
-    using ValueType = T;
+    using ValueType = S;
 
     Signal() = delete;
 
@@ -175,13 +180,13 @@ class Signal<T, unique> : public SignalBase<T>
         { }
 };
 
-template <typename T>
-class Signal<T, shared> : public SignalBase<T>
+template <typename S>
+class Signal<S, shared> : public SignalBase<S>
 {
 public:
     using SignalBase::SignalBase;
 
-    using ValueType = T;
+    using ValueType = S;
 
     Signal() = delete;
 
@@ -191,15 +196,15 @@ class Signal<T, shared> : public SignalBase<T>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
-    Signal(Signal<T, unique>&& other) :
+    Signal(Signal<S, unique>&& other) :
         Signal::SignalBase( std::move(other) )
         { }
 
-    Signal& operator=(Signal<T, unique>&& other)
+    Signal& operator=(Signal<S, unique>&& other)
         { Signal::SignalBase::operator=(std::move(other)); return *this; }
 
-    template <typename F, typename ... Us>
-    Signal(F&& func, const SignalBase<Us>& ... deps) :
+    template <typename F, typename ... Ts>
+    Signal(F&& func, const SignalBase<Ts>& ... deps) :
         Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
         { }
 };
@@ -207,13 +212,13 @@ class Signal<T, shared> : public SignalBase<T>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class VarSignal<T, unique> : public VarSignalBase<T>
+template <typename S>
+class VarSignal<S, unique> : public VarSignalBase<S>
 {
 public:
     using VarSignalBase::VarSignalBase;
 
-    using ValueType = T;
+    using ValueType = S;
 
     VarSignal() = delete;
 
@@ -223,19 +228,19 @@ class VarSignal<T, unique> : public VarSignalBase<T>
     VarSignal(VarSignal&&) = default;
     VarSignal& operator=(VarSignal&&) = default;
 
-    template <typename U, typename TGroup>
-    VarSignal(U&& value, const TGroup& group) :
-        VarSignal::VarSignalBase( CreateVarNode(std::forward<U>(value), group) )
+    template <typename T, typename TGroup>
+    VarSignal(T&& value, const TGroup& group) :
+        VarSignal::VarSignalBase( CreateVarNode(std::forward<T>(value), group) )
         { }
 };
 
-template <typename T>
-class VarSignal<T, shared> : public VarSignalBase<T>
+template <typename S>
+class VarSignal<S, shared> : public VarSignalBase<S>
 {
 public:
     using VarSignalBase::VarSignalBase;
 
-    using ValueType = T;
+    using ValueType = S;
 
     VarSignal() = delete;
 
@@ -245,16 +250,16 @@ class VarSignal<T, shared> : public VarSignalBase<T>
     VarSignal(VarSignal&&) = default;
     VarSignal& operator=(VarSignal&&) = default;
 
-    VarSignal(VarSignal<T, unique>&& other) :
+    VarSignal(VarSignal<S, unique>&& other) :
         VarSignal::VarSignalBase( std::move(other) )
         { }
 
-    VarSignal& operator=(VarSignal<T, unique>&& other)
+    VarSignal& operator=(VarSignal<S, unique>&& other)
         { VarSignal::SignalBase::operator=(std::move(other)); return *this; }
 
-    template <typename U, typename TGroup>
-    VarSignal(U&& value, const TGroup& group) :
-        VarSignal::VarSignalBase( CreateVarNode(std::forward<U>(value), group) )
+    template <typename T, typename TGroup>
+    VarSignal(T&& value, const TGroup& group) :
+        VarSignal::VarSignalBase( CreateVarNode(std::forward<T>(value), group) )
         { }
 };
 
diff --git a/include/react/detail/ObserverBase.h b/include/react/detail/ObserverBase.h
index 73f637fd..6653ff04 100644
--- a/include/react/detail/ObserverBase.h
+++ b/include/react/detail/ObserverBase.h
@@ -15,8 +15,6 @@
 #include <vector>
 #include <utility>
 
-#include "IReactiveNode.h"
-
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 4c4fdc35..e3b8d584 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -86,10 +86,10 @@ class IterateNode : public SignalNode<S>
 {
 public:
     template <typename U, typename V>
-    IterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& init, const std::shared_ptr<EventStreamNode<E>>& events, V&& func) :
+    IterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func) :
         IterateNode::SignalNode( graphPtr, std::forward<U>(init) ),
         events_( events ),
-        func_( std::forward<V>(func) )
+        func_( std::forward<FIn>(func) )
     {
         this->RegisterMe();
         this->AttachToMe(events->GetNodeId());
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index a68df789..124636fc 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -293,11 +293,11 @@ template <typename TOut, typename TIn, typename F>
 class EventProcessingNode : public EventStreamNode<TOut>
 {
 public:
-    template <typename U>
-    EventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func) :
+    template <typename FIn>
+    EventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep) :
         EventProcessingNode::EventStreamNode( graphPtr ),
-        dep_( dep ),
-        func_( std::forward<U>(func) )
+        func_( std::forward<FIn>(func) ),
+        dep_( dep )
     {
         this->RegisterMe();
         this->AttachToMe(dep->GetNodeId());
@@ -328,9 +328,9 @@ class EventProcessingNode : public EventStreamNode<TOut>
         { return 1; }
 
 private:
-    std::shared_ptr<EventStreamNode<TIn>> dep_;
-
     F func_;
+
+    std::shared_ptr<EventStreamNode<TIn>> dep_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -340,11 +340,11 @@ template <typename TOut, typename TIn, typename F, typename ... TSyncs>
 class SyncedEventProcessingNode : public EventStreamNode<TOut>
 {
 public:
-    template <typename U>
-    SyncedEventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIn>>& dep, U&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+    template <typename FIn>
+    SyncedEventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
         SyncedEventProcessingNode::EventStreamNode( graphPtr ),
+        func_( std::forward<FIn>(func) ),
         dep_( dep ),
-        func_( std::forward<U>(func) ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
@@ -364,7 +364,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         this->SetCurrentTurn(turnId, true);
         // Update of this node could be triggered from deps,
         // so make sure source doesnt contain events from last turn
-        source_->SetCurrentTurn(turnId);
+        dep_->SetCurrentTurn(turnId);
 
         apply(
             [this] (const auto& ... syncs)
@@ -386,10 +386,10 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         { return 1 + sizeof...(TSyncs); }
 
 private:
-    std::shared_ptr<EventStreamNode<TIn>>   dep_;
-
     F func_;
 
+    std::shared_ptr<EventStreamNode<TIn>>   dep_;
+
     std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
@@ -473,7 +473,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     template <typename U>
     static void FetchBuffer(TurnId turnId, Slot<U>& slot)
     {
-        slot.Source->SetCurrentTurn(turnId);
+        slot.source->SetCurrentTurn(turnId);
         slot.buffer.insert(slot.buffer.end(), slot.source->Events().begin(), slot.source->Events().end());
     }
 

From bd4c67ad0f6e5c511b7910b043c72458c6897e71 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sat, 6 Aug 2016 17:45:04 +0200
Subject: [PATCH 32/75] Redesign progress.

---
 examples/src/BasicSignals.cpp              | 337 ++++-------------
 include/react/API.h                        |   7 +
 include/react/Algorithm.h                  |  30 +-
 include/react/Event.h                      |  88 +++--
 include/react/Group.h                      |  28 +-
 include/react/Observer.h                   | 403 +++++++--------------
 include/react/Reactor.h                    |  76 ----
 include/react/Signal.h                     |  81 +++--
 include/react/detail/EngineBase.h          |  49 ---
 include/react/detail/ObserverBase.h        |  77 ----
 include/react/detail/graph/EventNodes.h    |   6 +-
 include/react/detail/graph/GraphBase.h     |   4 +-
 include/react/detail/graph/ObserverNodes.h |  95 +++--
 include/react/detail/graph/SignalNodes.h   |  84 +++--
 project/msvc/CppReact.vcxproj              |   2 -
 project/msvc/CppReact.vcxproj.filters      |   6 -
 16 files changed, 415 insertions(+), 958 deletions(-)
 delete mode 100644 include/react/Reactor.h
 delete mode 100644 include/react/detail/EngineBase.h
 delete mode 100644 include/react/detail/ObserverBase.h

diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 7f6943f2..bebdf7bf 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -12,7 +12,8 @@
 #include <vector>
 
 #include "react/Signal.h"
-/*
+#include "react/Observer.h"
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Hello world
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -21,74 +22,37 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    // Defines a domain.
+    // The concat function
+    string ConcatFunc(string first, string second)
+        { return first + string(" ") + second; }
+
+    // Defines a group.
     // Each domain represents a separate dependency graph, managed by a dedicated propagation engine.
     // Reactives of different domains can not be combined.
-    ReactiveGroup
-
-    // Define type aliases for the given domain in this namespace.
-    // Now we can use VarSignalT instead of D::VarSignalT.
-    USING_REACTIVE_DOMAIN(D)
-
-    // The concat function
-    string concatFunc(string first, string second) {
-        return first + string(" ") + second;
-    }
+    ReactiveGroup<> group;
+    
+    // The two words
+    VarSignal<string> firstWord( string("Change"), group );
+    VarSignal<string> secondWord( string("me!"), group );
 
     // A signal that concatenates both words
-    namespace v1
-    {
-        // The two words
-        VarSignalT<string>  firstWord( string("Change") );
-        VarSignalT<string>  secondWord( string("me!") );
-
-        SignalT<string>  bothWords = MakeSignal(With(firstWord,secondWord), concatFunc);
-
-        void Run()
-        {
-            cout << "Example 1 - Hello world (MakeSignal)" << endl;
-
-            // Imperative imperative value access
-            cout  << bothWords.Value() << endl;
-
-            // Imperative imperative change
-            firstWord  <<= string("Hello");
-
-            cout  << bothWords.Value() << endl;
-
-            secondWord <<= string("World");
-
-            cout  << bothWords.Value() << endl;
-
-            cout << endl;
-        }
-    }
+    Signal<string> bothWords(ConcatFunc, firstWord, secondWord);
 
-    // Using overloaded operator + instead of explicit MakeSignal
-    namespace v2
+    void Run()
     {
-        // The two words
-        VarSignalT<string>  firstWord   = MakeVar<D>(string("Change"));
-        VarSignalT<string>  secondWord  = MakeVar<D>(string("me!"));
-
-        SignalT<string> bothWords = firstWord + string(" ") + secondWord;
+        cout << "Example 1 - Hello world" << endl;
 
-        void Run()
-        {
-            cout << "Example 1 - Hello world (operators)" << endl;
+        cout  << bothWords.Value() << endl;
 
-            cout  << bothWords.Value() << endl;
+        firstWord <<= string("Hello");
 
-            firstWord  <<= string("Hello");
+        cout << bothWords.Value() << endl;
 
-            cout  << bothWords.Value() << endl;
+        secondWord <<= string("World");
 
-            secondWord <<= string("World");
+        cout << bothWords.Value() << endl;
 
-            cout  << bothWords.Value() << endl;
-
-            cout << endl;
-        }
+        cout << endl;
     }
 }
 
@@ -100,19 +64,19 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
-    VarSignalT<int> x    = MakeVar<D>(1);
-    SignalT<int>    xAbs = MakeSignal(x, [] (int x) { return abs(x); });
+    VarSignal<int> x( 1, group );
+
+    Signal<int> xAbs( [] (int v) { return abs(v); }, x);
 
     void Run()
     {
         cout << "Example 2 - Reacting to value changes" << endl;
 
-        Observe(xAbs, [] (int newValue) {
-            cout << "xAbs changed to " << newValue << endl;
-        });
+        Observer<> obs(
+            [] (int newValue) { cout << "xAbs changed to " << newValue << endl; },
+            xAbs );
 
                     // initially x is 1
         x <<=  2;   // output: xAbs changed to 2
@@ -131,28 +95,31 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    int sumFunc(int a, int b)
+        { return a + b; }
+
+    ReactiveGroup<> group;
 
-    VarSignalT<int> a = MakeVar<D>(1);
-    VarSignalT<int> b = MakeVar<D>(1);
+    VarSignal<int> a( 1, group );
+    VarSignal<int> b( 1, group );
 
-    SignalT<int>     x = a + b;
-    SignalT<int>     y = a + b;
-    SignalT<int>     z = x + y;
+    Signal<int> x( sumFunc, a, b );
+    Signal<int> y( sumFunc, a, b );
+    Signal<int> z( sumFunc, x, y );
 
     void Run()
     {
         cout << "Example 3 - Changing multiple inputs" << endl;
 
-        Observe(z, [] (int newValue) {
-            std::cout << "z changed to " << newValue << std::endl;
-        });
+        Observer<> obs(
+            [] (int newValue) { cout << "z changed to " << newValue << endl; },
+            z );
 
         a <<= 2; // output: z changed to 6
         b <<= 2; // output: z changed to 8
 
-        DoTransaction<D>([] {
+        group.DoTransaction([&]
+        {
             a <<= 4;
             b <<= 4; 
         }); // output: z changed to 16
@@ -169,27 +136,24 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
-    VarSignalT<vector<string>> data = MakeVar<D>(vector<string>{ });
+    VarSignal<vector<string>> data( group );
 
     void Run()
     {
         cout << "Example 4 - Modifying signal values in place" << endl;
 
-        data.Modify([] (vector<string>& data) {
-            data.push_back("Hello");
-        });
+        data.Modify([] (vector<string>& data)
+            { data.push_back("Hello"); });
 
-        data.Modify([] (vector<string>& data) {
-            data.push_back("World");
-        });
+        data.Modify([] (vector<string>& data)
+            { data.push_back("World"); });
 
         for (const auto& s : data.Value())
             cout << s << " ";
         cout << endl;
-        // output: Hell World
+        // output: Hello World
 
         cout << endl;
     }
@@ -203,168 +167,49 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
     // Helpers
-    using ExprPairT = pair<string,int>;
-    using ExprVectT = vector<ExprPairT>;
+    using ExprPairType = pair<string, int>;
+    using ExprVectType = vector<ExprPairType>;
 
-    string makeExprStr(int a, int b, const char* op)
+    string MakeExprStr(int a, int b, const char* op)
     {
         return to_string(a) + string(op) + to_string(b);
     }
 
-    ExprPairT makeExprPair(const string& s, int v)
-    {
-        return make_pair(s, v);
-    }
-
-    void printExpressions(const ExprVectT& expressions)
+    void PrintExpressions(const ExprVectType& expressions)
     {
         cout << "Expressions: " << endl;
         for (const auto& p : expressions)
             cout << "\t" << p.first << " is " << p.second << endl;
     }
 
-    // Version 1 - Intermediate signals
-    namespace v1
-    {
-        // Input operands
-        VarSignalT<int> a = MakeVar<D>(1);
-        VarSignalT<int> b = MakeVar<D>(2);
-
-        // Calculations
-        SignalT<int> sum  = a + b;
-        SignalT<int> diff = a - b;
-        SignalT<int> prod = a * b;
-
-        using std::placeholders::_1;
-        using std::placeholders::_2;
-
-        // Stringified expressions
-        SignalT<string> sumExpr =
-            MakeSignal(With(a,b), bind(makeExprStr, _1, _2, "+"));
-
-        SignalT<string> diffExpr =
-            MakeSignal(With(a,b), bind(makeExprStr, _1, _2, "-"));
-
-        SignalT<string> prodExpr =
-            MakeSignal(With(a,b), bind(makeExprStr, _1, _2, "*"));
-
-        // The expression vector
-        SignalT<ExprVectT> expressions = MakeSignal(
-            With(
-                MakeSignal(With(sumExpr, sum),   &makeExprPair),
-                MakeSignal(With(diffExpr, diff), &makeExprPair),
-                MakeSignal(With(prodExpr, prod), &makeExprPair)
-            ),
-            [] (const ExprPairT& sumP, const ExprPairT& diffP, const ExprPairT& prodP) {
-                return ExprVectT{ sumP, diffP, prodP};
-            });
-
-        void Run()
-        {
-            cout << "Example 5 - Complex signals (v1)" << endl;
-
-            Observe(expressions, printExpressions);
-
-            a <<= 10;
-            b <<= 20;
-
-            cout << endl;
-        }
-    }
+    // Input operands
+    VarSignal<int> a( 1, group );
+    VarSignal<int> b( 2, group );
 
-    // Version 2 - Intermediate signals in a function
-    namespace v2
-    {
-        SignalT<ExprVectT> createExpressionSignal(const SignalT<int>& a, const SignalT<int>& b)
-        {
-            using std::placeholders::_1;
-            using std::placeholders::_2;
-
-            // Inside a function, we can use auto
-            auto sumExpr =
-                MakeSignal(With(a,b), bind(makeExprStr, _1, _2, "+"));
-
-            auto diffExpr =
-                MakeSignal(With(a,b), bind(makeExprStr, _1, _2, "-"));
-
-            auto prodExpr =
-                MakeSignal(With(a,b), bind(makeExprStr, _1, _2, "*"));
-
-            return MakeSignal(
-                With(
-                    MakeSignal(With(sumExpr,  a + b), &makeExprPair),
-                    MakeSignal(With(diffExpr, a - b), &makeExprPair),
-                    MakeSignal(With(prodExpr, a * b), &makeExprPair)
-                ),
-                [] (const ExprPairT& sumP, const ExprPairT& diffP, const ExprPairT& prodP) {
-                    return ExprVectT{ sumP, diffP, prodP };
-                });
-        }
-
-        // Input operands
-        VarSignalT<int> a = MakeVar<D>(1);
-        VarSignalT<int> b = MakeVar<D>(2);
-
-        // The expression vector
-        SignalT<ExprVectT> expressions = createExpressionSignal(a, b);
-
-        void Run()
+    // The expression vector
+    Signal<ExprVectType> expressions(
+        [] (int a, int b)
         {
-            cout << "Example 5 - Complex signals (v2)" << endl;
-
-            Observe(expressions, printExpressions);
-
-            a <<= 30;
-            b <<= 40;
-
-            cout << endl;
-        }
-    }
-
-    // Version 3 - Imperative function
-    namespace v3
-    {
-        // Input operands
-        VarSignalT<int> a = MakeVar<D>(1);
-        VarSignalT<int> b = MakeVar<D>(2);
-
-        // The expression vector
-        SignalT<ExprVectT> expressions = MakeSignal(With(a,b), [] (int a, int b) {
-            ExprVectT result;
-
-            result.push_back(
-                make_pair(
-                    makeExprStr(a, b, "+"),
-                    a + b));
-
-            result.push_back(
-                make_pair(
-                    makeExprStr(a, b, "-"),
-                    a - b));
-
-            result.push_back(
-                make_pair(
-                    makeExprStr(a, b, "*"),
-                    a * b));
-
+            ExprVectType result;
+            result.push_back(make_pair(MakeExprStr(a, b, "+"), a + b));
+            result.push_back(make_pair(MakeExprStr(a, b, "-"), a - b));
+            result.push_back(make_pair(MakeExprStr(a, b, "*"), a * b));
             return result;
-        });
+        }, a, b );
 
-        void Run()
-        {
-            cout << "Example 5 - Complex signals (v3)" << endl;
+    void Run()
+    {
+        cout << "Example 5 - Complex signals (v3)" << endl;
 
-            Observe(expressions, printExpressions);
+        Observer<> obs(PrintExpressions, expressions);
 
-            a <<= 50;
-            b <<= 60;
+        a <<= 50;
+        b <<= 60;
 
-            cout << endl;
-        }
+        cout << endl;
     }
 }
 
@@ -373,45 +218,11 @@ namespace example5
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    example1::v1::Run();
-    example1::v2::Run();
-
+    example1::Run();
     example2::Run();
-
     example3::Run();
-
     example4::Run();
-
-    example5::v1::Run();
-    example5::v2::Run();
-    example5::v3::Run();
-
-    return 0;
-}
-
-*/
-
-using namespace react;
-
-int main()
-{
-    auto group = ReactiveGroup<shared>( );
-
-    auto sig1 = VarSignal<int, unique>( 1, group );
-    auto sig2 = VarSignal<int, shared>( 2, group );
-
-    sig1.Set(1);
-    sig1 <<= 1;
-
-    sig2.Modify([] (int& value) { value = 3; });
-
-    group.DoTransaction(
-        [&]
-        {
-            sig1 <<= 2;
-        });
-
-    auto sig3 = Signal<int, unique>( [] (auto a, auto b) { return a + b; }, sig1, sig2 );
+    example5::Run();
 
     return 0;
 }
\ No newline at end of file
diff --git a/include/react/API.h b/include/react/API.h
index b445b74c..68b6f531 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -23,6 +23,12 @@ enum OwnershipPolicy
     shared
 };
 
+enum ReferencePolicy
+{
+    strong,
+    weak
+};
+
 enum ThreadingPolicy
 {
     sequential,
@@ -81,6 +87,7 @@ class EventSource;
 enum class Token;
 
 // Observers
+template <OwnershipPolicy = unique>
 class Observer;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index d41d0fef..e6624d74 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -171,7 +171,7 @@ auto Iterate(const Events<E>& events, V&& init, const SignalPack<TDepValues...>&
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Snapshot(const Signal<S>& signal, const Events<E>& trigger) -> Signal<S>
+auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& trigger) -> Signal<S, unique>
 {
     using REACT_IMPL::SnapshotNode;
     using REACT_IMPL::GetCheckedGraphPtr;
@@ -185,40 +185,16 @@ auto Snapshot(const Signal<S>& signal, const Events<E>& trigger) -> Signal<S>
 /// Pulse - Emits value of target signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Pulse(const Signal<S>& signal, const Events<E>& trigger) -> Events<S>
+auto Pulse(const SignalBase<S>& signal, const EventBase<E>& trigger) -> Event<S, unique>
 {
     using REACT_IMPL::PulseNode;
     using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
 
-    return Events<S, unique>( std::make_shared<PulseNode<S, E>>(
+    return Event<S, unique>( std::make_shared<PulseNode<S, E>>(
         GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Changed - Emits token when target signal was changed
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-auto Changed(const Signal<T>& target) -> Events<Token>
-{
-    return Monitor(target).Tokenize();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ChangedTo - Emits token when target signal was changed to value
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename T,
-    typename V,
->
-auto ChangedTo(const Signal<T>& target, V&& value) -> Events<Token>
-{
-    return Monitor(target)
-        .Filter([=] (const S& v) { return v == value; })
-        .Tokenize();
-}
-
 /******************************************/ REACT_END /******************************************/
 
 #endif // REACT_ALGORITHM_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Event.h b/include/react/Event.h
index e244ec46..637268ff 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -24,7 +24,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Events
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename E = Token>
 class EventBase
 {
@@ -32,16 +31,6 @@ class EventBase
     using NodeType = REACT_IMPL::EventStreamNode<E>;
 
 public:
-    EventBase() = default;
-
-    EventBase(const EventBase&) = default;
-    EventBase& operator=(const EventBase&) = default;
-
-    EventBase(EventBase&&) = default;
-    EventBase& operator=(EventBase&&) = default;
-
-    ~EventBase() = default;
-
     // Node ctor
     explicit EventBase(std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
@@ -63,6 +52,14 @@ class EventBase
         { return REACT::Transform(*this, std::forward<F>(f)); }*/
 
 protected:
+    EventBase() = default;
+
+    EventBase(const EventBase&) = default;
+    EventBase& operator=(const EventBase&) = default;
+
+    EventBase(EventBase&&) = default;
+    EventBase& operator=(EventBase&&) = default;
+
     auto NodePtr() -> std::shared_ptr<NodeType>&
         { return nodePtr_; }
 
@@ -72,23 +69,23 @@ class EventBase
     template <typename F, typename T>
     auto CreateProcessingNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
     {
-        using ProcessingNodeType = REACT_IMPL::EventProcessingNode<E, T, typename std::decay<F>::type>;
+        using REACT_IMPL::PrivateNodeInterface;
+        using EventNodeType = REACT_IMPL::EventProcessingNode<E, T, typename std::decay<F>::type>;
 
-        return std::make_shared<ProcessingNodeType>(
-            REACT_IMPL::PrivateNodeInterface::GraphPtr(dep),
-            std::forward<F>(func),
-            REACT_IMPL::PrivateNodeInterface::NodePtr(dep));
+        return std::make_shared<EventNodeType>(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), PrivateNodeInterface::NodePtr(dep));
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedProcessingNode(F&& func, const EventBase<T>& dep, const SignalBase<Us> ... syncs) -> decltype(auto)
+    auto CreateSyncedProcessingNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
     {
-        using SyncedProcessingNodeType = REACT_IMPL::SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>;
+        using REACT_IMPL::GetCheckedGraphPtr;
+        using REACT_IMPL::PrivateNodeInterface;
+        using EventNodeType = REACT_IMPL::SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>;
 
-        return std::make_shared<SyncedProcessingNodeType>(
-            REACT_IMPL::GetCheckedGraphPtr(dep, syncs ...),
+        return std::make_shared<EventNodeType>(
+            GetCheckedGraphPtr(dep, syncs ...),
             std::forward<F>(func),
-            REACT_IMPL::PrivateNodeInterface::NodePtr(dep), REACT_IMPL::PrivateNodeInterface::NodePtr(syncs) ...);
+            PrivateNodeInterface::NodePtr(dep), PrivateNodeInterface::NodePtr(syncs) ...);
     }
 
 private:
@@ -108,19 +105,6 @@ class EventSourceBase : public EventBase<E>
 
 public:
     using EventBase::EventBase;
-
-    EventSourceBase() = default;
-
-    EventSourceBase(const EventSourceBase&) = default;
-    EventSourceBase& operator=(const EventSourceBase&) = default;
-
-    EventSourceBase(EventSourceBase&& other) = default;
-    EventSourceBase& operator=(EventSourceBase&& other) = default;
-
-    template <typename TGroup>
-    explicit EventSourceBase(const TGroup& group) :
-        EventSourceBase::EventBase( std::make_shared<NodeType>(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
     
     void Emit(const E& value)
         { EmitValue(value); }
@@ -138,6 +122,24 @@ class EventSourceBase : public EventBase<E>
     EventSourceBase& operator<<(E&& value)
         { EmitValue(std::move(value)); return *this; }
 
+protected:
+    EventSourceBase() = default;
+
+    EventSourceBase(const EventSourceBase&) = default;
+    EventSourceBase& operator=(const EventSourceBase&) = default;
+
+    EventSourceBase(EventSourceBase&& other) = default;
+    EventSourceBase& operator=(EventSourceBase&& other) = default;
+
+    template <typename TGroup>
+    auto CreateSourceNode(const TGroup& group) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
+
+        return std::make_shared<NodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
+    }
+
 private:
     template <typename T>
     void EmitValue(T&& value)
@@ -178,7 +180,7 @@ class Event<E, unique> : public EventBase<E>
         { }
 
     template <typename F, typename T, typename ... Us>
-    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us> ... signals) :
+    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
         Event::EventBase( CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
         { }
 };
@@ -212,7 +214,7 @@ class Event<E, shared> : public EventBase<E>
         { }
 
     template <typename F, typename T, typename ... Us>
-    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us> ... signals) :
+    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
         Event::EventBase( SyncedCreateProcessingNode(std::forward<F>(func), dep, signals ...) )
         { }
 };
@@ -235,6 +237,12 @@ class EventSource<E, unique> : public EventSourceBase<E>
 
     EventSource(EventSource&&) = default;
     EventSource& operator=(EventSource&&) = default;
+
+    // Construct event source
+    template <typename TGroup>
+    explicit EventSource(const TGroup& group) :
+        EventSource::EventSourceBase( CreateSourceNode(group) )
+        { }
 };
 
 template <typename E>
@@ -253,10 +261,18 @@ class EventSource<E, shared> : public EventSourceBase<E>
     EventSource(EventSource&&) = default;
     EventSource& operator=(EventSource&&) = default;
 
+    // Construct event source
+    template <typename TGroup>
+    explicit EventSource(const TGroup& group) :
+        EventSource::EventSourceBase( CreateSourceNode(group) )
+        { }
+
+    // Construct from unique
     EventSource(EventSource<E, unique>&& other) :
         EventSource::EventSourceBase( std::move(other) )
         { }
 
+    // Assign from unique
     EventSource& operator=(EventSource<E, unique>&& other)
         { EventSource::EventSourceBase::operator=(std::move(other)); return *this; }
 };
diff --git a/include/react/Group.h b/include/react/Group.h
index cf58e72a..71434d1e 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -86,23 +86,6 @@ class TransactionStatus
     friend void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& func);
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////
-/// DoTransaction
-///////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename F>
-void DoTransaction(F&& func)
-{
-    using REACT_IMPL::DomainSpecificInputManager;
-    DomainSpecificInputManager<D>::Instance().DoTransaction(0, std::forward<F>(func));
-}
-
-template <typename D, typename F>
-void DoTransaction(TransactionFlags flags, F&& func)
-{
-    using REACT_IMPL::DomainSpecificInputManager;
-    DomainSpecificInputManager<D>::Instance().DoTransaction(flags, std::forward<F>(func));
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// AsyncTransaction
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -221,6 +204,15 @@ class ReactiveGroup<shared> : public ReactiveGroupBase
 
     ReactiveGroup(ReactiveGroup&& other) = default;
     ReactiveGroup& operator=(ReactiveGroup&& other) = default;
+
+    // Construct from unique
+    ReactiveGroup(ReactiveGroup<unique>&& other) :
+        ReactiveGroup::ReactiveGroupBase( std::move(other) )
+        { }
+
+    // Assign from unique
+    ReactiveGroup& operator=(ReactiveGroup<unique>&& other)
+        { ReactiveGroup::ReactiveGroupBase::operator=(std::move(other)); return *this; }
 };
 
 /******************************************/ REACT_END /******************************************/
@@ -260,7 +252,7 @@ static auto GetCheckedGraphPtr(const TBase1& dep1, const TBases& ... deps) -> co
 {
     const std::shared_ptr<IReactiveGraph>& graphPtr1 = PrivateNodeInterface::GraphPtr(dep1);
 
-    auto rawGraphPtrs = { PrivateNodeInterface::GraphPtr(deps).get() ... };
+    std::initializer_list<IReactiveGraph*> rawGraphPtrs = { PrivateNodeInterface::GraphPtr(deps).get() ... };
 
     bool isSameGraphForAllDeps = std::all_of(rawGraphPtrs.begin(), rawGraphPtrs.end(), [&] (IReactiveGraph* p) { return p == graphPtr1.get(); });
 
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 705d4ee9..9d5c6409 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -4,337 +4,176 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#if 0
-
 #ifndef REACT_OBSERVER_H_INCLUDED
 #define REACT_OBSERVER_H_INCLUDED
 
 #pragma once
 
 #include "react/detail/Defs.h"
+#include "react/API.h"
+#include "react/Group.h"
 
 #include <memory>
 #include <utility>
 
-#include "react/common/Util.h"
-#include "react/detail/IReactiveNode.h"
-#include "react/detail/ObserverBase.h"
 #include "react/detail/graph/ObserverNodes.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class Signal;
-
-template <typename E>
-class Events;
-
-using REACT_IMPL::ObserverAction;
-using REACT_IMPL::WeightHint;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Observer
+/// ObserverBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class Observer
+class ObserverBase
 {
 private:
-    using SubjectPtrT   = std::shared_ptr<REACT_IMPL::ObservableNode<D>>;
-    using NodeT         = REACT_IMPL::ObserverNode<D>;
+    using NodeType = REACT_IMPL::ObserverNode;
 
 public:
-    // Default ctor
-    Observer() :
-        nodePtr_( nullptr ),
-        subjectPtr_( nullptr )
-    {}
-
-    // Move ctor
-    Observer(Observer&& other) :
-        nodePtr_( other.nodePtr_ ),
-        subjectPtr_( std::move(other.subjectPtr_) )
-    {
-        other.nodePtr_ = nullptr;
-        other.subjectPtr_.reset();
-    }
+    // Private node ctor
+    explicit ObserverBase(std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
 
-    // Node ctor
-    Observer(NodeT* nodePtr, const SubjectPtrT& subjectPtr) :
-        nodePtr_( nodePtr ),
-        subjectPtr_( subjectPtr )
-    {}
+    void Cancel()
+        { nodePtr_.reset(); }
 
-    // Move assignment
-    Observer& operator=(Observer&& other)
-    {
-        nodePtr_ = other.nodePtr_;
-        subjectPtr_ = std::move(other.subjectPtr_);
+    bool IsCancelled() const
+        { return nodePtr_ != nullptr; }
 
-        other.nodePtr_ = nullptr;
-        other.subjectPtr_.reset();
+protected:
+    ObserverBase() = default;
 
-        return *this;
-    }
+    ObserverBase(const ObserverBase&) = default;
+    ObserverBase& operator=(const ObserverBase&) = default;
 
-    // Deleted copy ctor and assignment
-    Observer(const Observer&) = delete;
-    Observer& operator=(const Observer&) = delete;
+    ObserverBase(ObserverBase&&) = default;
+    ObserverBase& operator=(ObserverBase&&) = default;
 
-    void Detach()
-    {
-        assert(IsValid());
-        subjectPtr_->UnregisterObserver(nodePtr_);
-    }
+    auto NodePtr() -> std::shared_ptr<NodeType>&
+        { return nodePtr_; }
 
-    bool IsValid() const
-    {
-        return nodePtr_ != nullptr;
-    }
+    auto NodePtr() const -> const std::shared_ptr<NodeType>&
+        { return nodePtr_; }
 
-    void SetWeightHint(WeightHint weight)
+    template <typename F, typename T1, typename ... Ts>
+    auto CreateSignalObserverNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-        assert(IsValid());
-        nodePtr_->SetWeightHint(weight);
+        using REACT_IMPL::GetCheckedGraphPtr;
+        using REACT_IMPL::PrivateNodeInterface;
+        using ObsNodeType = REACT_IMPL::SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>;
+
+        return std::make_shared<ObsNodeType>(
+            GetCheckedGraphPtr(dep1, deps ...),
+            std::forward<F>(func),
+            PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...);
     }
 
-private:
-    // Owned by subject
-    NodeT*          nodePtr_;
-
-    // While the observer handle exists, the subject is not destroyed
-    SubjectPtrT     subjectPtr_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ScopedObserver
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class ScopedObserver
-{
-public:
-    // Move ctor
-    ScopedObserver(ScopedObserver&& other) :
-        obs_( std::move(other.obs_) )
-    {}
-
-    // Construct from observer
-    ScopedObserver(Observer<D>&& obs) :
-        obs_( std::move(obs) )
-    {}
-
-    // Move assignment
-    ScopedObserver& operator=(ScopedObserver&& other)
+    template <typename F, typename T>
+    auto CreateEventObserverNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
     {
-        obs_ = std::move(other.obs_);
-    }
+        using REACT_IMPL::PrivateNodeInterface;
+        using ObsNodeType = REACT_IMPL::EventObserverNode<typename std::decay<F>::type, T>;
 
-    // Deleted default ctor, copy ctor and assignment
-    ScopedObserver() = delete;
-    ScopedObserver(const ScopedObserver&) = delete;
-    ScopedObserver& operator=(const ScopedObserver&) = delete;
-
-    ~ScopedObserver()
-    {
-        obs_.Detach();
+        return std::make_shared<ObsNodeType>(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), PrivateNodeInterface::NodePtr(dep));
     }
 
-    bool IsValid() const
+    template <typename F, typename T, typename ... Us>
+    auto CreateSyncedEventObserverNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
     {
-        return obs_.IsValid();
-    }
-
-    void SetWeightHint(WeightHint weight)
-    {
-        obs_.SetWeightHint(weight);
+        using REACT_IMPL::GetCheckedGraphPtr;
+        using REACT_IMPL::PrivateNodeInterface;
+        using ObsNodeType = REACT_IMPL::SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>;
+
+        return std::make_shared<ObsNodeType>(
+            GetCheckedGraphPtr(dep, syncs ...),
+            std::forward<F>(func),
+            PrivateNodeInterface::NodePtr(dep), PrivateNodeInterface::NodePtr(syncs) ...);
     }
 
 private:
-    Observer<D>     obs_;    
+    std::shared_ptr<NodeType> nodePtr_;
+
+    friend struct REACT_IMPL::PrivateNodeInterface;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Observe - Signals
+/// Observer
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename FIn,
-    typename S
->
-auto Observe(const Signal<D,S>& subject, FIn&& func)
-    -> Observer<D>
+template <>
+class Observer<unique> : public ObserverBase
 {
-    using REACT_IMPL::IObserver;
-    using REACT_IMPL::ObserverNode;
-    using REACT_IMPL::SignalObserverNode;
-    using REACT_IMPL::AddDefaultReturnValueWrapper;
-
-    using F = typename std::decay<FIn>::type;
-    using R = typename std::result_of<FIn(S)>::type;
-    using WrapperT = AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>;
-
-    // If return value of passed function is void, add ObserverAction::next as
-    // default return value.
-    using NodeT = typename std::conditional<
-        std::is_same<void,R>::value,
-        SignalObserverNode<D,S,WrapperT>,
-        SignalObserverNode<D,S,F>
-            >::type;
-
-    const auto& subjectPtr = GetNodePtr(subject);
-
-    std::unique_ptr<ObserverNode<D>> nodePtr( new NodeT(subjectPtr, std::forward<FIn>(func)) );
-    ObserverNode<D>* rawNodePtr = nodePtr.get();
+public:
+    using ObserverBase::ObserverBase;
 
-    subjectPtr->RegisterObserver(std::move(nodePtr));
+    Observer() = delete;
 
-    return Observer<D>( rawNodePtr, subjectPtr );
-}
+    Observer(const Observer&) = delete;
+    Observer& operator=(const Observer&) = delete;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Observe - Events
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename FIn,
-    typename E
->
-auto Observe(const Events<D,E>& subject, FIn&& func)
-    -> Observer<D>
-{
-    using REACT_IMPL::IObserver;
-    using REACT_IMPL::ObserverNode;
-    using REACT_IMPL::EventObserverNode;
-    using REACT_IMPL::AddDefaultReturnValueWrapper;
-    using REACT_IMPL::AddObserverRangeWrapper;
-    using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::EventRange;
-
-    using F = typename std::decay<FIn>::type;
-
-    using WrapperT =
-        typename std::conditional<
-            IsCallableWith<F, ObserverAction, EventRange<E>>::value,
-            F,
-            typename std::conditional<
-                IsCallableWith<F, ObserverAction, E>::value,
-                AddObserverRangeWrapper<E, F>,
-                typename std::conditional<
-                    IsCallableWith<F, void, EventRange<E>>::value,
-                    AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
-                    typename std::conditional<
-                        IsCallableWith<F, void, E>::value,
-                        AddObserverRangeWrapper<E,
-                            AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>>,
-                        void
-                    >::type
-                >::type
-            >::type
-        >::type;
-
-    static_assert(
-        ! std::is_same<WrapperT,void>::value,
-        "Observe: Passed function does not match any of the supported signatures.");
-    
-    using NodeT = EventObserverNode<D,E,WrapperT>;
-    
-    const auto& subjectPtr = GetNodePtr(subject);
-
-    std::unique_ptr<ObserverNode<D>> nodePtr( new NodeT(subjectPtr, std::forward<FIn>(func)) );
-    ObserverNode<D>* rawNodePtr = nodePtr.get();
-
-    subjectPtr->RegisterObserver(std::move(nodePtr));
-
-    return Observer<D>( rawNodePtr, subjectPtr );
-}
+    Observer(Observer&&) = default;
+    Observer& operator=(Observer&&) = default;
+
+    // Construct signal observer
+    template <typename F, typename ... Ts>
+    Observer(F&& func, const SignalBase<Ts>& ... subjects) :
+        Observer::ObserverBase( CreateSignalObserverNode(std::forward<F>(func), subjects ...) )
+        { }
+
+    // Construct event observer
+    template <typename F, typename T>
+    Observer(F&& func, const EventBase<T>& subject) :
+        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject ) )
+        { }
+
+    // Constructed synced event observer
+    template <typename F, typename T, typename ... Us>
+    Observer(F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
+        Observer::ObserverBase( CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...) )
+        { }
+};
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Observe - Synced
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename FIn,
-    typename E,
-    typename ... TDepValues
->
-auto Observe(const Events<D,E>& subject,
-             const SignalPack<D,TDepValues...>& depPack, FIn&& func)
-    -> Observer<D>
+template <>
+class Observer<shared> : public ObserverBase
 {
-    using REACT_IMPL::IObserver;
-    using REACT_IMPL::ObserverNode;
-    using REACT_IMPL::SyncedObserverNode;
-    using REACT_IMPL::AddDefaultReturnValueWrapper;
-    using REACT_IMPL::AddObserverRangeWrapper;
-    using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::EventRange;
-
-    using F = typename std::decay<FIn>::type;
-
-    using WrapperT =
-        typename std::conditional<
-            IsCallableWith<F, ObserverAction, EventRange<E>, TDepValues ...>::value,
-            F,
-            typename std::conditional<
-                IsCallableWith<F, ObserverAction, E, TDepValues ...>::value,
-                AddObserverRangeWrapper<E, F, TDepValues ...>,
-                typename std::conditional<
-                    IsCallableWith<F, void, EventRange<E>, TDepValues ...>::value,
-                    AddDefaultReturnValueWrapper<F, ObserverAction ,ObserverAction::next>,
-                    typename std::conditional<
-                        IsCallableWith<F, void, E, TDepValues ...>::value,
-                        AddObserverRangeWrapper<E,
-                            AddDefaultReturnValueWrapper<F,ObserverAction,ObserverAction::next>,
-                                TDepValues...>,
-                            void
-                        >::type
-                >::type
-            >::type
-        >::type;
-
-    static_assert(
-        ! std::is_same<WrapperT,void>::value,
-        "Observe: Passed function does not match any of the supported signatures.");
-
-    using NodeT = SyncedObserverNode<D,E,WrapperT,TDepValues ...>;
-
-    struct NodeBuilder_
-    {
-        NodeBuilder_(const Events<D,E>& subject, FIn&& func) :
-            MySubject( subject ),
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> ObserverNode<D>*
-        {
-            return new NodeT(
-                GetNodePtr(MySubject), std::forward<FIn>(MyFunc), GetNodePtr(deps) ... );
-        }
-
-        const Events<D,E>& MySubject;
-        FIn MyFunc;
-    };
-
-    const auto& subjectPtr = GetNodePtr(subject);
-
-    std::unique_ptr<ObserverNode<D>> nodePtr( REACT_IMPL::apply(
-        NodeBuilder_( subject, std::forward<FIn>(func) ),
-        depPack.Data) );
-
-    ObserverNode<D>* rawNodePtr = nodePtr.get();
-
-    subjectPtr->RegisterObserver(std::move(nodePtr));
-
-    return Observer<D>( rawNodePtr, subjectPtr );
-}
+public:
+    using ObserverBase::ObserverBase;
+
+    Observer() = delete;
+
+    Observer(const Observer&) = default;
+    Observer& operator=(const Observer&) = default;
+
+    Observer(Observer&&) = default;
+    Observer& operator=(Observer&&) = default;
+
+    // Construct from unique
+    Observer(Observer<unique>&& other) :
+        Observer::ObserverBase( std::move(other) )
+        { }
+
+    // Assign from unique
+    Observer& operator=(Observer<unique>&& other)
+        { Observer::ObserverBase::operator=(std::move(other)); return *this; }
+
+    // Construct signal observer
+    template <typename F, typename ... Ts>
+    Observer(F&& func, const SignalBase<Ts>& ... subjects) :
+        Observer::ObserverBase( CreateSignalObserverNode(std::forward<F>(func), subjects ...) )
+        { }
+
+    // Construct event observer
+    template <typename F, typename T>
+    Observer(F&& func, const EventBase<T>& subject) :
+        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject ) )
+        { }
+
+    // Constructed synced event observer
+    template <typename F, typename T, typename ... Us>
+    Observer(F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
+        Observer::ObserverBase( CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...) )
+        { }
+};
 
 /******************************************/ REACT_END /******************************************/
 
-#endif // REACT_OBSERVER_H_INCLUDED
-
-#endif
\ No newline at end of file
+#endif // REACT_OBSERVER_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Reactor.h b/include/react/Reactor.h
deleted file mode 100644
index 92d3b006..00000000
--- a/include/react/Reactor.h
+++ /dev/null
@@ -1,76 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_REACTOR_H_INCLUDED
-#define REACT_REACTOR_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <functional>
-#include <memory>
-#include <utility>
-
-#include "react/common/Util.h"
-
-#include "react/Event.h"
-#include "react/detail/ReactiveBase.h"
-#include "react/detail/graph/ReactorNodes.h"
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-template <typename D>
-class Reactor
-{
-public:
-    class Context;
-
-    using NodeT = REACT_IMPL::ReactorNode<D,Context>;
-    
-    class Context
-    {
-    public:
-        Context(NodeT& node) :
-            node_( node )
-        {}
-
-        template <typename E>
-        E& Await(const Events<D,E>& evn)
-        {
-            return node_.Await(GetNodePtr(evn));
-        }
-
-        template <typename E, typename F>
-        void RepeatUntil(const Events<D,E>& evn, F&& func)
-        {
-            node_.RepeatUntil(GetNodePtr(evn), std::forward<F>(func));
-        }
-
-        template <typename S>
-        const S& Get(const Signal<D,S>& sig)
-        {
-            return node_.Get(GetNodePtr(sig));
-        }
-
-    private:
-        NodeT&    node_;
-    };
-
-    template <typename F>
-    explicit Reactor(F&& func) :
-        nodePtr_( new REACT_IMPL::ReactorNode<D, Context>(std::forward<F>(func)) )
-    {
-        nodePtr_->StartLoop();
-    }
-
-private:
-    std::unique_ptr<NodeT>    nodePtr_;
-};
-
-/******************************************/ REACT_END /******************************************/
-
-#endif // REACT_REACTOR_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Signal.h b/include/react/Signal.h
index e8222bf3..c46a0b94 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -36,16 +36,6 @@ class SignalBase
     using NodeType = REACT_IMPL::SignalNode<S>;
 
 public:
-    SignalBase() = default;
-
-    SignalBase(const SignalBase&) = default;
-    SignalBase& operator=(const SignalBase&) = default;
-
-    SignalBase(SignalBase&&) = default;
-    SignalBase& operator=(SignalBase&&) = default;
-
-    ~SignalBase() = default;
-
     // Private node ctor
     explicit SignalBase(std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
@@ -55,6 +45,14 @@ class SignalBase
         { return nodePtr_->Value(); }
 
 protected:
+    SignalBase() = default;
+
+    SignalBase(const SignalBase&) = default;
+    SignalBase& operator=(const SignalBase&) = default;
+
+    SignalBase(SignalBase&&) = default;
+    SignalBase& operator=(SignalBase&&) = default;
+
     auto NodePtr() -> std::shared_ptr<NodeType>&
         { return nodePtr_; }
 
@@ -66,7 +64,6 @@ class SignalBase
     {
         using REACT_IMPL::GetCheckedGraphPtr;
         using REACT_IMPL::PrivateNodeInterface;
-
         using FuncNodeType = REACT_IMPL::SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<FuncNodeType>(
@@ -90,14 +87,6 @@ class VarSignalBase : public SignalBase<S>
 public:
     using SignalBase::SignalBase;
 
-    VarSignalBase() = default;
-
-    VarSignalBase(const VarSignalBase&) = default;
-    VarSignalBase& operator=(const VarSignalBase&) = default;
-
-    VarSignalBase(VarSignalBase&&) = default;
-    VarSignalBase& operator=(VarSignalBase&&) = default;
-
     void Set(const S& newValue)
         { SetValue(newValue); }
 
@@ -115,11 +104,27 @@ class VarSignalBase : public SignalBase<S>
         { ModifyValue(func); }
 
 protected:
+    VarSignalBase() = default;
+
+    VarSignalBase(const VarSignalBase&) = default;
+    VarSignalBase& operator=(const VarSignalBase&) = default;
+
+    VarSignalBase(VarSignalBase&&) = default;
+    VarSignalBase& operator=(VarSignalBase&&) = default;
+
+    template <typename TGroup>
+    auto CreateVarNode(const TGroup& group) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
+
+        return std::make_shared<VarNodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
+    }
+
     template <typename T, typename TGroup>
     auto CreateVarNode(T&& value, const TGroup& group) -> decltype(auto)
     {
         using REACT_IMPL::PrivateReactiveGroupInterface;
-
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         return std::make_shared<VarNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value));
@@ -174,9 +179,10 @@ class Signal<S, unique> : public SignalBase<S>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
-    template <typename F, typename ... Us>
-    Signal(F&& func, const SignalBase<Us>& ... deps) :
-        SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
+    // Construct func signal
+    template <typename F, typename ... Ts>
+    Signal(F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
         { }
 };
 
@@ -196,17 +202,20 @@ class Signal<S, shared> : public SignalBase<S>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
+    // Construct func signal
+    template <typename F, typename ... Ts>
+    Signal(F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
+        { }
+
+    // Construct from unique
     Signal(Signal<S, unique>&& other) :
         Signal::SignalBase( std::move(other) )
         { }
 
+    // Assign from unique
     Signal& operator=(Signal<S, unique>&& other)
         { Signal::SignalBase::operator=(std::move(other)); return *this; }
-
-    template <typename F, typename ... Ts>
-    Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
-        { }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -228,6 +237,13 @@ class VarSignal<S, unique> : public VarSignalBase<S>
     VarSignal(VarSignal&&) = default;
     VarSignal& operator=(VarSignal&&) = default;
 
+    // Construct with default
+    template <typename TGroup>
+    explicit VarSignal(const TGroup& group) :
+        VarSignal::VarSignalBase( CreateVarNode( group) )
+        { }
+
+    // Construct with value
     template <typename T, typename TGroup>
     VarSignal(T&& value, const TGroup& group) :
         VarSignal::VarSignalBase( CreateVarNode(std::forward<T>(value), group) )
@@ -250,13 +266,22 @@ class VarSignal<S, shared> : public VarSignalBase<S>
     VarSignal(VarSignal&&) = default;
     VarSignal& operator=(VarSignal&&) = default;
 
+    // Construct from unique
     VarSignal(VarSignal<S, unique>&& other) :
         VarSignal::VarSignalBase( std::move(other) )
         { }
 
+    // Assign from unique
     VarSignal& operator=(VarSignal<S, unique>&& other)
         { VarSignal::SignalBase::operator=(std::move(other)); return *this; }
 
+    // Construct with default
+    template <typename TGroup>
+    explicit VarSignal(const TGroup& group) :
+        VarSignal::VarSignalBase( CreateVarNode( group) )
+        { }
+
+    // Construct with value
     template <typename T, typename TGroup>
     VarSignal(T&& value, const TGroup& group) :
         VarSignal::VarSignalBase( CreateVarNode(std::forward<T>(value), group) )
diff --git a/include/react/detail/EngineBase.h b/include/react/detail/EngineBase.h
deleted file mode 100644
index 501c9c26..00000000
--- a/include/react/detail/EngineBase.h
+++ /dev/null
@@ -1,49 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_ENGINEBASE_H_INCLUDED
-#define REACT_DETAIL_ENGINEBASE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <utility>
-#include <vector>
-
-#include "tbb/queuing_mutex.h"
-
-#include "react/common/Concurrency.h"
-#include "react/common/Types.h"
-#include "react/detail/ReactiveInput.h"
-#include "react/detail/IReactiveNode.h"
-#include "react/detail/IReactiveEngine.h"
-#include "react/detail/ObserverBase.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TurnBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class TurnBase
-{
-public:
-    inline TurnBase(TurnIdT id, TransactionFlagsT flags) :
-        id_( id )
-    {}
-
-    inline TurnIdT Id() const { return id_; }
-
-private:
-    TurnIdT    id_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_ENGINEBASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/ObserverBase.h b/include/react/detail/ObserverBase.h
deleted file mode 100644
index 6653ff04..00000000
--- a/include/react/detail/ObserverBase.h
+++ /dev/null
@@ -1,77 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_OBSERVERBASE_H_INCLUDED
-#define REACT_DETAIL_OBSERVERBASE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <memory>
-#include <vector>
-#include <utility>
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IObserver
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class IObserver
-{
-public:
-    virtual ~IObserver() {}
-
-    virtual void UnregisterSelf() = 0;
-
-private:
-    virtual void detachObserver() = 0;
-
-    template <typename D>
-    friend class Observable;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Observable
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class Observable
-{
-public:
-    Observable() = default;
-
-    ~Observable()
-    {
-        for (const auto& p : observers_)
-            if (p != nullptr)
-                p->detachObserver();
-    }
-
-    void RegisterObserver(std::unique_ptr<IObserver>&& obsPtr)
-    {
-        observers_.push_back(std::move(obsPtr));
-    }
-
-    void UnregisterObserver(IObserver* rawObsPtr)
-    {
-        for (auto it = observers_.begin(); it != observers_.end(); ++it)
-        {
-            if (it->get() == rawObsPtr)
-            {
-                it->get()->detachObserver();
-                observers_.erase(it);
-                break;
-            }
-        }
-    }
-
-private:
-    std::vector<std::unique_ptr<IObserver>> observers_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_OBSERVERBASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 124636fc..bd966944 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -99,7 +99,8 @@ class EventStreamNode : public NodeBase
         //});
     }
 
-    explicit EventStreamNode(const std::shared_ptr<IReactiveGraph>& graphPtr) : NodeBase( graphPtr )
+    explicit EventStreamNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+        NodeBase( graphPtr )
         { }
 
     StorageType&  Events()
@@ -122,7 +123,8 @@ template <typename T>
 class EventSourceNode : public EventStreamNode<T>
 {
 public:
-    EventSourceNode(const std::shared_ptr<IReactiveGraph>& graphPtr) : EventSourceNode::EventStreamNode( graphPtr )
+    EventSourceNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+        EventSourceNode::EventStreamNode( graphPtr )
         { this->RegisterMe(); }
 
     ~EventSourceNode()
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 43d091da..b694e34e 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -18,7 +18,6 @@
 #include "react/common/Types.h"
 #include "react/common/Util.h"
 #include "react/detail/IReactiveGraph.h"
-#include "react/detail/ObserverBase.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
@@ -30,7 +29,8 @@ struct IReactiveGraph;
 class NodeBase : public IReactiveNode
 {
 public:
-    NodeBase(const std::shared_ptr<IReactiveGraph>& graphPtr) : graphPtr_( graphPtr )
+    NodeBase(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+        graphPtr_( graphPtr )
         { }
     
     NodeBase(const NodeBase&) = delete;
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index b90e118e..0713c157 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -23,27 +23,22 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
+template <typename S>
 class SignalNode;
 
-template <typename T>
+template <typename E>
 class EventStreamNode;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObserverNode
+/// SignalObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class ObserverNode : public NodeBase, public IObserver
+class ObserverNode : public NodeBase
 {
 public:
-    ObserverNode(IReactiveGraph* group) : NodeBase( group )
+    ObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+        ObserverNode::NodeBase( graphPtr )
         { }
 
-    ObserverNode(ObserverNode&&) = default;
-    ObserverNode& operator=(ObserverNode&&) = default;
-
-    ObserverNode(const ObserverNode&) = delete;
-    ObserverNode& operator=(const ObserverNode&) = delete;
-
     virtual bool IsOutputNode() const
         { return true; }
 };
@@ -51,56 +46,56 @@ class ObserverNode : public NodeBase, public IObserver
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F>
+template <typename F, typename ... TDeps>
 class SignalObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SignalObserverNode(IReactiveGraph* group, const std::shared_ptr<SignalNode<T>>& subject, FIn&& func) :
-        SignalObserverNode::ObserverNode( group ),
-        subject_( subject ),
-        func_( std::forward<FIn>(func) )
+    SignalObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
+        SignalObserverNode::ObserverNode( graphPtr ),
+        func_( std::forward<FIn>(func) ),
+        depHolder_( deps ... )
     {
         this->RegisterMe();
-        this->AttachToMe(subject->GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
     ~SignalObserverNode()
     {
-        this->DetachFromMe(subject->GetNodeId());
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(deps->GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
     virtual const char* GetNodeType() const override
         { return "SignalObserver"; }
 
-    virtual int DependencyCount() const override
-        { return 1; }
+    virtual int GetDependencyCount() const override
+        { return sizeof...(TDeps); }
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        func_(subject_->Value());
+        apply([this] (const auto& ... deps) { this->func_(deps->Value() ...); }, depHolder_);
         return UpdateResult::unchanged;
     }
 
 private:
-    std::shared_ptr<SignalNode<T>> subject_;
-
     F func_;
+
+    std::tuple<std::shared_ptr<SignalNode<TDeps>> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F>
+template <typename F, typename E>
 class EventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    EventObserverNode(IReactiveGraph* group, const std::shared_ptr<EventStreamNode<T>>& subject, FIn&& func) :
-        EventObserverNode::ObserverNode( group ),
-        subject_( subject ),
-        func_( std::forward<FIn>(func) )
+    EventObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject) :
+        EventObserverNode::ObserverNode( graphPtr ),
+        func_( std::forward<FIn>(func) ),
+        subject_( subject )
     {
         this->RegisterMe();
         this->AttachToMe(subject->GetNodeId());
@@ -108,40 +103,40 @@ class EventObserverNode : public ObserverNode
 
     ~EventObserverNode()
     {
-        this->DetachFromMe(subject->GetNodeId());
+        this->DetachFromMe(subject_->GetNodeId());
         this->UnregisterMe();
     }
 
     virtual const char* GetNodeType() const override
-        { return "EventObserverNode"; }
+        { return "EventObserver"; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return 1; }
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        func_(EventRange<T>( subject_->Events() ));
+        func_(EventRange<E>( subject_->Events() ));
         return UpdateResult::unchanged;
     }
 
 private:
-    std::shared_ptr<EventStreamNode<T>> subject_;
-
     F func_;
+
+    std::shared_ptr<EventStreamNode<E>> subject_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedObserverNode
+/// SyncedEventObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F, typename ... TSyncs>
-class SyncedObserverNode : public ObserverNode
+template <typename F, typename E, typename ... TSyncs>
+class SyncedEventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SyncedObserverNode(IReactiveGraph* group, const std::shared_ptr<EventStreamNode<T>>& subject, FIn&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedObserverNode::ObserverNode( group ),
-        subject_( subject ),
+    SyncedEventObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedEventObserverNode::ObserverNode( graphPtr ),
         func_( std::forward<FIn>(func) ),
+        subject_( subject ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
@@ -149,7 +144,7 @@ class SyncedObserverNode : public ObserverNode
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
-    ~SyncedObserverNode()
+    ~SyncedEventObserverNode()
     {
         apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
         this->DetachFromMe(subject_->GetNodeId());
@@ -157,32 +152,26 @@ class SyncedObserverNode : public ObserverNode
     }
 
     virtual const char* GetNodeType() const override
-        { return "SyncedObserverNode"; }
+        { return "SyncedEventObserver"; }
 
-    virtual int DependencyCount() const override
+    virtual int GetDependencyCount() const override
         { return 1 + sizeof...(TSyncs); }
 
     virtual UpdateResult Update(TurnId turnId) override
     {   
         // Update of this node could be triggered from deps,
         // so make sure source doesnt contain events from last turn
-        p->SetCurrentTurn(turnId);
-            
-        shouldDetach = apply(
-            [this] (const auto& ... syncs)
-            {
-                func_(EventRange<E>( this->subject_->Events() ), syncs->Value() ...);
-            },
-            syncHolder_);
+        subject_->SetCurrentTurn(turnId);
 
+        apply([this] (const auto& ... syncs) { func_(EventRange<E>( this->subject_->Events() ), syncs->Value() ...); }, syncHolder_);
         return UpdateResult::unchanged;
     }
 
 private:
-    std::shared_ptr<EventStreamNode<T>> subject_;
-    
     F func_;
 
+    std::shared_ptr<EventStreamNode<E>> subject_;
+
     std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index b926ffa1..d45366e1 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -27,7 +27,7 @@ bool Equals(const L& lhs, const R& rhs);
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
+template <typename S>
 class SignalNode : public NodeBase
 {
 public:
@@ -37,29 +37,39 @@ class SignalNode : public NodeBase
     SignalNode(const SignalNode&) = delete;
     SignalNode& operator=(const SignalNode&) = delete;
 
-    template <typename U>
-    SignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& value) :
+    explicit SignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+        SignalNode::NodeBase( graphPtr ),
+        value_( )
+        { }
+
+    template <typename T>
+    SignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& value) :
         SignalNode::NodeBase( graphPtr ),
         value_( std::forward<T>(value) )
         { }
 
-    T& Value()
+    S& Value()
         { return value_; }
 
-    const T& Value() const
+    const S& Value() const
         { return value_; }
 
 private:
-    T value_;
+    S value_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class VarSignalNode : public SignalNode<T>
+template <typename S>
+class VarSignalNode : public SignalNode<S>
 {
 public:
+    explicit VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+        VarSignalNode::SignalNode( graphPtr ),
+        newValue_( )
+        { this->RegisterMe(); }
+
     template <typename T>
     VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& value) :
         VarSignalNode::SignalNode( graphPtr, std::forward<T>(value) ),
@@ -84,7 +94,7 @@ class VarSignalNode : public SignalNode<T>
         {
             isInputAdded_ = false;
 
-            if (! Equals(this->Value(), newValue_))
+            if (! (this->Value() == newValue_))
             {
                 this->Value() = std::move(newValue_);
                 return UpdateResult::changed;
@@ -106,10 +116,10 @@ class VarSignalNode : public SignalNode<T>
         }
     }
 
-    template <typename U>
-    void SetValue(U&& newValue)
+    template <typename T>
+    void SetValue(T&& newValue)
     {
-        newValue_ = std::forward<U>(newValue);
+        newValue_ = std::forward<T>(newValue);
 
         isInputAdded_ = true;
 
@@ -139,7 +149,7 @@ class VarSignalNode : public SignalNode<T>
     }
 
 private:
-    T       newValue_;
+    S       newValue_;
     bool    isInputAdded_ = false;
     bool    isInputModified_ = false;
 };
@@ -147,14 +157,14 @@ class VarSignalNode : public SignalNode<T>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SignalOpNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename F, typename ... TDeps>
-class SignalFuncNode : public SignalNode<T>
+template <typename S, typename F, typename ... TDeps>
+class SignalFuncNode : public SignalNode<S>
 {
 public:
-    template <typename U>
-    SignalFuncNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
+    template <typename FIn>
+    SignalFuncNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
         SignalFuncNode::SignalNode( graphPtr, func(deps->Value() ...) ),
-        func_( std::forward<U>(func) ),
+        func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
         this->RegisterMe();
@@ -167,13 +177,19 @@ class SignalFuncNode : public SignalNode<T>
         this->UnregisterMe();
     }
 
+    virtual const char* GetNodeType() const override
+        { return "SignalFunc"; }
+
+    virtual int GetDependencyCount() const override
+        { return sizeof...(TDeps); }
+
     virtual UpdateResult Update(TurnId turnId) override
     {   
         bool changed = false;
 
-        T newValue = apply([this] (const auto& ... deps) { return this->func_(deps->Value() ...); }, depHolder_);
+        S newValue = apply([this] (const auto& ... deps) { return this->func_(deps->Value() ...); }, depHolder_);
 
-        if (! Equals(this->Value(), newValue))
+        if (! (this->Value() == newValue))
         {
             this->Value() = std::move(newValue);
             changed = true;
@@ -185,16 +201,10 @@ class SignalFuncNode : public SignalNode<T>
             return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SignalFunc"; }
-
-    virtual int GetDependencyCount() const override
-        { return sizeof...(TDeps); }
-
 private:
-    std::tuple<std::shared_ptr<SignalNode<TDeps>> ...> depHolder_;
-
     F func_;
+
+    std::tuple<std::shared_ptr<SignalNode<TDeps>> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -221,6 +231,15 @@ class SignalFlattenNode : public SignalNode<TInner>
         this->UnregisterMe();
     }
 
+    virtual const char* GetNodeType() const override
+        { return "SignalFlatten"; }
+
+    virtual bool IsDynamicNode() const override
+        { return true; }
+
+    virtual int GetDependencyCount() const override
+        { return 2; }
+
     virtual UpdateResult Update(TurnId turnId) override
     {
         auto newInner = GetNodePtr(outer_->Value());
@@ -248,15 +267,6 @@ class SignalFlattenNode : public SignalNode<TInner>
         }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SignalFlatten"; }
-
-    virtual bool IsDynamicNode() const override
-        { return true; }
-
-    virtual int GetDependencyCount() const override
-        { return 2; }
-
 private:
     std::shared_ptr<SignalNode<TOuter>> outer_;
     std::shared_ptr<SignalNode<TInner>> inner_;
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 0d380c1c..7ef4b0dc 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -160,10 +160,8 @@
     <ClInclude Include="..\..\include\react\detail\graph\ObserverNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\PropagationST.h" />
     <ClInclude Include="..\..\include\react\detail\graph\PropagationMT.h" />
-    <ClInclude Include="..\..\include\react\detail\ObserverBase.h" />
     <ClInclude Include="..\..\include\react\detail\ReactiveInput.h" />
     <ClInclude Include="..\..\include\react\detail\Defs.h" />
-    <ClInclude Include="..\..\include\react\detail\EngineBase.h" />
     <ClInclude Include="..\..\include\react\detail\graph\AlgorithmNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h" />
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index 1174c9b1..c5384429 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -54,9 +54,6 @@
     <ClInclude Include="..\..\include\react\detail\Defs.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\EngineBase.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
@@ -66,9 +63,6 @@
     <ClInclude Include="..\..\include\react\detail\ReactiveInput.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\ObserverBase.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\graph\AlgorithmNodes.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>

From 5114927925c60319f3830ef8d9c8540fc4a162a9 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 7 Aug 2016 23:26:12 +0200
Subject: [PATCH 33/75] Redesign WIP. Removed reactor stuff. Fixed basic
 examples. Observers, algorithms. Event buffer clearing.

---
 examples/CMakeLists.txt                       |  12 -
 examples/src/BasicAlgorithms.cpp              | 238 +++++++++---------
 examples/src/BasicEvents.cpp                  | 188 +++++++-------
 examples/src/BasicObservers.cpp               | 142 ++---------
 examples/src/BasicReactors.cpp                | 161 ------------
 examples/src/BasicSignals.cpp                 |   4 +-
 include/react/API.h                           |  12 +-
 include/react/Algorithm.h                     | 142 +++--------
 include/react/Event.h                         |  26 +-
 include/react/Group.h                         |   3 +-
 include/react/Signal.h                        |  18 +-
 include/react/common/Util.h                   |   6 +
 include/react/detail/IReactiveGraph.h         |  34 +--
 include/react/detail/graph/AlgorithmNodes.h   |  88 ++++---
 include/react/detail/graph/EventNodes.h       |  79 ++----
 include/react/detail/graph/GraphBase.h        |  13 +-
 include/react/detail/graph/ObserverNodes.h    |  10 +-
 include/react/detail/graph/PropagationST.h    |  45 +++-
 include/react/detail/graph/SignalNodes.h      |  13 +-
 project/msvc/CppReact.sln                     |  15 +-
 project/msvc/Example_BasicReactors.vcxproj    |   3 -
 .../Example_BasicReactors.vcxproj.filters     |   5 -
 22 files changed, 421 insertions(+), 836 deletions(-)
 delete mode 100644 examples/src/BasicReactors.cpp

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 940479ae..417819a0 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -14,18 +14,6 @@ target_link_libraries(Example_BasicEvents CppReact)
 add_executable(Example_BasicObservers src/BasicObservers.cpp)
 target_link_libraries(Example_BasicObservers CppReact)
 
-### Example_BasicReactors
-find_package(Boost 1.55 COMPONENTS coroutine context system)
-if(Boost_FOUND)
-	include_directories(${Boost_INCLUDE_DIRS}) 
-	add_executable(Example_BasicReactors src/BasicReactors.cpp)
-	target_link_libraries(Example_BasicReactors CppReact ${Boost_LIBRARIES})
-else()
-	message("boost::coroutine not found. Skipping build of Example_BasicReactors.")
-endif()
-#add_exyecutable(Example_BasicReactors src/BasicReactors.cpp)
-#target_link_libraries(Example_BasicReactors CppReact)
-
 ### Example_BasicSignals
 add_executable(Example_BasicSignals src/BasicSignals.cpp)
 target_link_libraries(Example_BasicSignals CppReact)
diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index dd20b7bc..1e84305d 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -9,7 +9,6 @@
 #include <utility>
 #include <vector>
 
-#include "react/Domain.h"
 #include "react/Signal.h"
 #include "react/Event.h"
 #include "react/Observer.h"
@@ -23,15 +22,12 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup<> group;
 
-    class Sensor
+    struct Sensor
     {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        EventSourceT<int>   Samples     = MakeEventSource<D,int>();
-        SignalT<int>        LastSample  = Hold(Samples, 0);
+        EventSource<int>   samples      { group };
+        Signal<int>        lastSample   = Hold(0, samples);
     };
 
     void Run()
@@ -40,14 +36,18 @@ namespace example1
 
         Sensor mySensor;
 
-        Observe(mySensor.LastSample, [] (int v) {
-            std::cout << v << std::endl;
-        });
+        Observer<> obs(
+            [] (int v)
+            {
+                cout << v << endl;
+            },
+            mySensor.lastSample);
 
-        mySensor.Samples << 20 << 21 << 21 << 22; // output: 20, 21, 22
+        mySensor.samples << 20 << 21 << 21 << 22; // output: 20, 21, 22
 
-        DoTransaction<D>([&] {
-            mySensor.Samples << 30 << 31 << 31 << 32;
+        group.DoTransaction([&]
+        {
+            mySensor.samples << 30 << 31 << 31 << 32;
         }); // output: 32
 
         cout << endl;
@@ -62,17 +62,12 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup<> group;
 
-    class Employee
+    struct Employee
     {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        VarSignalT<string>   Name    = MakeVar<D>(string( "Bob" ));
-        VarSignalT<int>      Salary  = MakeVar<D>(3000);
-
-        EventsT<int>         SalaryChanged = Monitor(Salary);
+        VarSignal<string>   name    { string( "Bob" ), group };
+        VarSignal<int>      salary  { 3000, group };
     };
 
     void Run()
@@ -81,12 +76,13 @@ namespace example2
 
         Employee bob;
 
-        Observe(
-            bob.SalaryChanged,
-            With(bob.Name),
-            [] (int newSalary, const string& name) {
-                cout << name << " now earns " << newSalary << endl;
-            });
+        Observer<> obs(
+            [] (EventRange<int> in, const string& name)
+            {
+                for (int newSalary : in)
+                    cout << name << " now earns " << newSalary << endl;
+            },
+            Monitor(bob.salary), bob.name);
 
         cout << endl;
     }
@@ -100,21 +96,21 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup<> group;
 
-    class Counter
+    struct Counter
     {
-    public:
-        USING_REACTIVE_DOMAIN(D)
+        EventSource<> increment { group };
 
-        EventSourceT<>  Increment = MakeEventSource<D>();
-
-        SignalT<int> Count = Iterate(
-            Increment,
+        Signal<int> count = Iterate<int>(
             0,
-            [] (Token, int oldCount) {
-                return oldCount + 1;
-            });
+            [] (EventRange<> in, int count)
+            {
+                for (auto _ : in)
+                    ++count;
+                return count;
+            },
+            increment);
     };
 
     void Run()
@@ -123,12 +119,11 @@ namespace example3
 
         Counter myCounter;
 
-        // Note: Using function-style operator() instead of .Emit() and .Value()
-        myCounter.Increment();
-        myCounter.Increment();
-        myCounter.Increment();
+        myCounter.increment.Emit();
+        myCounter.increment.Emit();
+        myCounter.increment.Emit();
 
-        cout << myCounter.Count() << endl; // output: 3
+        cout << myCounter.count.Value() << endl; // output: 3
 
         cout << endl;
     }
@@ -142,34 +137,33 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup<> group;
 
-    class Sensor
+    struct Sensor
     {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        EventSourceT<float> Input = MakeEventSource<D,float>();
+        EventSource<float> input{ group };
 
-        SignalT<int> Count = Iterate(
-            Tokenize(Input),
+        Signal<int> count = Iterate<int>(
             0,
-            [] (Token, int oldCount) {
-                return oldCount + 1;
-            });
-
-        SignalT<float> Sum = Iterate(
-            Input,
+            [] (EventRange<float> in, int count)
+            {
+                for (auto _ : in)
+                    count++;
+                return count;
+            },
+            input);
+
+        Signal<float> sum = Iterate<float>(
             0.0f,
-            [] (float v, float sum) {
-                return v + sum;
-            });
-
-        SignalT<float> Average = MakeSignal(
-            With(Sum,Count),
-            [] (float sum, int count) {
-                return count != 0 ? sum / count : 0.0f;
-            });
+            [] (EventRange<float> in, float sum)
+            {
+                for (auto v : in)
+                    sum += v;
+                return sum;
+            },
+            input);
+
+        VarSignal<float> average{ group };
     };
 
     void Run()
@@ -178,9 +172,9 @@ namespace example4
 
         Sensor mySensor;
 
-        mySensor.Input << 10.0f << 5.0f << 10.0f << 8.0f;
+        mySensor.input << 10.0f << 5.0f << 10.0f << 8.0f;
 
-        cout << "Average: " << mySensor.Average() << endl; // output: 8.25
+        cout << "Average: " << mySensor.average.Value() << endl; // output: 8.25
 
         cout << endl;
     }
@@ -194,31 +188,35 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup<> group;
 
     enum ECmd { increment, decrement, reset };
 
     class Counter
     {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        EventSourceT<int>   Update  = MakeEventSource<D,int>();
-        VarSignalT<int>     Delta   = MakeVar<D>(1);
-        VarSignalT<int>     Start   = MakeVar<D>(0);
-
-        SignalT<int> Count = Iterate(
-            Update,
-            Start.Value(),
-            With(Delta, Start),
-            [] (int cmd, int oldCount, int delta, int start) {
+    private:
+        static int DoCounterLoop(EventRange<int> in, int count, int delta, int start)
+        {
+            for (int cmd : in)
+            {
                 if (cmd == increment)
-                    return oldCount + delta;
+                    count += delta;
                 else if (cmd == decrement)
-                    return oldCount - delta;
+                    count -= delta;
                 else
-                    return start;
-            });
+                    count = start;
+            }
+
+            return count;
+        }
+
+    public:
+        EventSource<int> update{ group };
+
+        VarSignal<int> delta{ 1, group };
+        VarSignal<int> start{ 0, group };
+
+        Signal<int> count{ Iterate<int>(start.Value(), DoCounterLoop, update, delta, start) };
     };
 
     void Run()
@@ -227,23 +225,23 @@ namespace example5
 
         Counter myCounter;
 
-        cout << "Start: " << myCounter.Count() << endl; // output: 0
+        cout << "Start: " << myCounter.count.Value() << endl; // output: 0
 
-        myCounter.Update(increment);
-        myCounter.Update(increment);
-        myCounter.Update(increment);
+        myCounter.update.Emit(increment);
+        myCounter.update.Emit(increment);
+        myCounter.update.Emit(increment);
 
-        cout << "3x increment by 1: " << myCounter.Count() << endl; // output: 3
+        cout << "3x increment by 1: " << myCounter.count.Value() << endl; // output: 3
 
-        myCounter.Delta <<= 5;
-        myCounter.Update(decrement);
+        myCounter.delta <<= 5;
+        myCounter.update.Emit(decrement);
 
-        cout << "1x decrement by 5: " << myCounter.Count() << endl; // output: -2
+        cout << "1x decrement by 5: " << myCounter.count.Value() << endl; // output: -2
 
-        myCounter.Start <<= 100;
-        myCounter.Update(reset);
+        myCounter.start <<= 100;
+        myCounter.update.Emit(reset);
 
-        cout << "reset to 100: " << myCounter.Count() << endl; // output: 100
+        cout << "reset to 100: " << myCounter.count.Value() << endl; // output: 100
 
         cout << endl;
     }
@@ -257,32 +255,32 @@ namespace example6
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    ReactiveGroup<> group;
 
     class Sensor
     {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        EventSourceT<int>   Input = MakeEventSource<D,int>();
-
-        VarSignalT<int>     Threshold = MakeVar<D>(42);
-
-        SignalT<vector<int>> AllSamples = Iterate(
-            Input,
-            vector<int>{},
-            [] (int input, vector<int>& all) {
+    private:
+        static void DoIterateAllSamples(EventRange<int> in, vector<int>& all)
+        {
+            for (int input : in)
                 all.push_back(input);
-            });
+        }
 
-        SignalT<vector<int>> CriticalSamples = Iterate(
-            Input,
-            vector<int>{},
-            With(Threshold),
-            [] (int input, vector<int>& critical, int threshold) {
+        static void DoIterateCritSamples(EventRange<int> in, vector<int>& critical, int threshold)
+        {
+            for (int input : in)
                 if (input > threshold)
                     critical.push_back(input);
-            });
+        }
+
+    public:
+        EventSource<int> input{ group };
+
+        VarSignal<int> threshold{ 42, group };
+
+        Signal<vector<int>> allSamples{ Iterate<vector<int>>(vector<int>{ }, DoIterateAllSamples, input) };
+
+        Signal<vector<int>> criticalSamples{ Iterate<vector<int>>(vector<int>{ }, DoIterateCritSamples, input, threshold) };
     };
 
     void Run()
@@ -291,15 +289,15 @@ namespace example6
 
         Sensor mySensor;
 
-        mySensor.Input << 40 << 29 << 43 << 50;
+        mySensor.input << 40 << 29 << 43 << 50;
 
         cout << "All samples: ";
-        for (auto const& v : mySensor.AllSamples())
+        for (auto const& v : mySensor.allSamples.Value())
             cout << v << " ";
         cout << endl;
 
         cout << "Critical samples: ";
-        for (auto const& v : mySensor.CriticalSamples())
+        for (auto const& v : mySensor.criticalSamples.Value())
             cout << v << " ";
         cout << endl;
 
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index 0db396c3..b9a7cfbd 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -8,7 +8,6 @@
 #include <string>
 #include <utility>
 
-#include "react/Domain.h"
 #include "react/Event.h"
 #include "react/Observer.h"
 
@@ -20,36 +19,33 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    // Defines a domain.
-    // Each domain represents a separate dependency graph, managed by a dedicated propagation engine.
-    // Reactives of different domains can not be combined.
-    REACTIVE_DOMAIN(D, sequential)
-
-    // Define type aliases for the given domain in this namespace.
-    // Now we can use EventSourceT instead of D::EventSourceT.
-    USING_REACTIVE_DOMAIN(D)
+    // Defines a group.
+    // Each group represents a separate dependency graph.
+    // Reactives from different groups can not be mixed.
+    ReactiveGroup<> group;
 
     // An event source that emits values of type string
     namespace v1
     {
-        EventSourceT<string> mySource = MakeEventSource<D,string>();
+        EventSource<string> mySource( group );
 
         void Run()
         {
             cout << "Example 1 - Hello world (string source)" << endl;
 
-            Observe(mySource, [] (const string& s) {
-                std::cout << s << std::endl;
-            });
+            Observer<> obs(
+                [] (EventRange<string> in)
+                {
+                    for (const auto& s : in)
+                        cout << s << std::endl;
+                },
+                mySource);
 
             mySource << string("Hello world #1");
 
             // Or without the operator:
             mySource.Emit(string("Hello world #2"));
 
-            // Or as a function call:
-            mySource(string("Hello world #3"));
-
             cout << endl;
         }
     }
@@ -57,7 +53,7 @@ namespace example1
     // An event source without an explicit value type
     namespace v2
     {
-        EventSourceT<> helloWorldTrigger = MakeEventSource<D>();
+        EventSource<> helloWorldTrigger( group );
 
         void Run()
         {
@@ -65,18 +61,19 @@ namespace example1
 
             int count = 0;
 
-            Observe(helloWorldTrigger, [&] (Token) {
-                cout << "Hello world #" << ++count << endl;
-            });
+            Observer<> obs(
+                [&] (EventRange<> in)
+                {
+                    for (auto t : in)
+                        cout << "Hello world #" << ++count << endl;
+                },
+                helloWorldTrigger);
 
             helloWorldTrigger.Emit();
 
             // Or without the stream operator:
             helloWorldTrigger << Token::value;
 
-            // Or as a function call:
-            helloWorldTrigger();
-
             cout << endl;
         }
     }
@@ -90,57 +87,32 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
     // An event stream that merges both sources
-    namespace v1
-    {
-        EventSourceT<> leftClick  = MakeEventSource<D>();
-        EventSourceT<> rightClick = MakeEventSource<D>();
-
-        EventsT<> anyClick = Merge(leftClick, rightClick);
-
-        void Run()
-        {
-            cout << "Example 2 - Merging event streams (Merge)" << endl;
+    EventSource<> leftClick( group );
+    EventSource<> rightClick( group );
 
-            int count = 0;
-
-            Observe(anyClick, [&] (Token) {
-                cout << "clicked #" << ++count << endl;
-            });
-
-            leftClick.Emit();  // output: clicked #1 
-            rightClick.Emit(); // output: clicked #2
+    Event<> anyClick = Merge(leftClick, rightClick);
 
-            cout << endl;
-        }
-    }
-
-    // Using overloaded operator | instead of explicit Merge
-    namespace v2
+    void Run()
     {
-        EventSourceT<> leftClick  = MakeEventSource<D>();
-        EventSourceT<> rightClick = MakeEventSource<D>();
+        cout << "Example 2 - Merging event streams (Merge)" << endl;
 
-        EventsT<> anyClick = leftClick | rightClick;
+        int count = 0;
 
-        void Run()
-        {
-            cout << "Example 2 - Merging event streams (operator)" << endl;
-
-            int count = 0;
-
-            Observe(anyClick, [&] (Token) {
-                cout << "clicked #" << ++count << endl;
-            });
+        Observer<> obs(
+            [&] (EventRange<> in)
+            {
+                for (auto t : in)
+                    cout << "clicked #" << ++count << endl;
+            },
+            anyClick);
 
-            leftClick.Emit();  // output: clicked #1
-            rightClick.Emit(); // output: clicked #2
+        leftClick.Emit();  // output: clicked #1 
+        rightClick.Emit(); // output: clicked #2
 
-            cout << endl;
-        }
+        cout << endl;
     }
 }
 
@@ -152,22 +124,23 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
-    EventSourceT<int> numbers = MakeEventSource<D,int>();
+    EventSource<int> numbers( group );
 
-    EventsT<int> greater10 = Filter(numbers, [] (int n) {
-        return n > 10;
-    });
+    Event<int> greater10 = Filter([] (int n) { return n > 10; }, numbers);
 
     void Run()
     {
         cout << "Example 3 - Filtering events" << endl;
 
-        Observe(greater10, [] (int n) {
-            cout << n << endl;
-        });
+        Observer<> obs(
+            [&] (EventRange<int> in)
+            {
+                for (auto n : in)
+                    cout << n << endl;
+            },
+            greater10);
 
         numbers << 5 << 11 << 7 << 100; // output: 11, 100
 
@@ -183,32 +156,40 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
     // Data types
-    enum class ETag { normal, critical };
-    using TaggedNum = pair<ETag,int>;
+    enum class Tag { normal, critical };
+    using TaggedNum = pair<Tag, int>;
 
-    EventSourceT<int> numbers = MakeEventSource<D,int>();
+    EventSource<int> numbers( group );
 
-    EventsT<TaggedNum> tagged = Transform(numbers, [] (int n) {
-        if (n > 10)
-            return TaggedNum( ETag::critical, n );
-        else
-            return TaggedNum( ETag::normal, n );
-    });
+    Event<TaggedNum> tagged = Transform<TaggedNum>(
+        [] (int n)
+        {
+            if (n > 10)
+                return TaggedNum( Tag::critical, n );
+            else
+                return TaggedNum( Tag::normal, n );
+        },
+        numbers);
 
     void Run()
     {
         cout << "Example 4 - Transforming  events" << endl;
 
-        Observe(tagged, [] (const TaggedNum& t) {
-            if (t.first == ETag::critical)
-                cout << "(critical) " << t.second << endl;
-            else
-                cout << "(normal)  " << t.second << endl;
-        });
+        Observer<> obs(
+            [] (EventRange<TaggedNum> in)
+            {
+                for (TaggedNum e : in)
+                {
+                    if (e.first == Tag::critical)
+                        cout << "(critical) " << e.second << endl;
+                    else
+                        cout << "(normal)  " << e.second << endl;
+                }
+            },
+            tagged);
 
         numbers << 5;   // output: (normal) 5
         numbers << 20;  // output: (critical) 20
@@ -225,20 +206,24 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
-    EventSourceT<int> src = MakeEventSource<D,int>();
+    EventSource<int> src( group );
 
     void Run()
     {
         cout << "Example 5 - Queuing multiple inputs" << endl;
 
-        Observe(src, [] (int v) {
-            cout << v << endl;
-        }); // output: 1, 2, 3, 4
+        Observer<> obs(
+            [] (EventRange<int> in)
+            {
+                for (int e : in)
+                    cout << e << endl;
+            }, src);
+        // output: 1, 2, 3, 4
 
-        DoTransaction<D>([] {
+        group.DoTransaction([]
+        {
             src << 1 << 2 << 3;
             src << 4;
         });
@@ -254,14 +239,9 @@ int main()
 {
     example1::v1::Run();
     example1::v2::Run();
-
-    example2::v1::Run();
-    example2::v2::Run();
-
+    example2::Run();
     example3::Run();
-
     example4::Run();
-
     example5::Run();
 
     return 0;
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index 2c1b911e..0a282528 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -8,7 +8,6 @@
 #include <string>
 #include <utility>
 
-#include "react/Domain.h"
 #include "react/Signal.h"
 #include "react/Event.h"
 #include "react/Observer.h"
@@ -21,77 +20,25 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
-    auto x = MakeVar<D>(1);
+    VarSignal<int> x( 1, group );
 
-    namespace v1
+    void Run()
     {
-        void Run()
-        {
-            cout << "Example 1 - Creating subject-bound observers (v1)" << endl;
-
-            {
-                // Create a signal in the function scope
-                auto mySignal = MakeSignal(x, [] (int x) { return x; } );
-
-                // The lifetime of the observer is bound to mySignal.
-                // After Run() returns, mySignal is destroyed, and so is the observer
-                Observe(mySignal, [] (int mySignal) {
-                    cout << mySignal << endl;
-                });
-
-                x <<= 2; // output: 2
-            }
+        cout << "Example 1 - Creating subject-bound observers (v1)" << endl;
 
-            x <<= 3; // no ouput
-
-            cout << endl;
-        }
-    }
-
-    namespace v2
-    {
-        void Run()
         {
-            cout << "Example 1 - Creating subject-bound observers (v2)" << endl;
-
-            // Outer scope
-            {
-                // Unbound observer
-                ObserverT obs; 
-
-                // Inner scope
-                {
-                    auto mySignal = MakeSignal(x, [] (int x) { return x; } );
-
-                    // Move-assign to obs
-                    obs = Observe(mySignal, [] (int mySignal) {
-                        cout << mySignal << endl;
-                    });
-
-                    // The node linked to mySignal is now also owned by obs
-
-                    x <<= 2; // output: 2
-                }
-                // ~Inner scope
-
-                // mySignal was destroyed, but as long as obs exists and is still
-                // attached to the signal node, this signal node won't be destroyed
+            Signal<int> mySignal( [] (int x) { return x; }, x );
 
-                x <<= 3; // output: 3
-            }
-            // ~Outer scope
+            Observer<> obs( [] (int mySignal) { cout << mySignal << endl; }, mySignal );
 
-            // obs was destroyed
-            // -> the signal node is no longer owned by anything and is destroyed
-            // -> the observer node is destroyed as it was bound to the subject
+            x <<= 2; // output: 2
+        }
 
-            x <<= 4; // no ouput
+        x <<= 3; // no ouput
 
-            cout << endl;
-        }
+        cout << endl;
     }
 }
 
@@ -103,71 +50,28 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
+    ReactiveGroup<> group;
 
-    EventSourceT<> trigger = MakeEventSource<D>();
+    EventSource<> trigger( group );
 
     void Run()
     {
         cout << "Example 2 - Detaching observers manually" << endl;
 
-        ObserverT obs = Observe(trigger, [] (Token) {
-            cout << "Triggered!" << endl;
-        });
+        Observer<> obs(
+            [] (EventRange<> in)
+            {
+                for (auto _ : in)
+                    cout << "Triggered!" << endl;
+            },
+            trigger);
 
         trigger.Emit(); // output: Triggered!
 
-        obs.Detach();   // Remove the observer
-
-        trigger.Emit(); // no output
-
-        cout << endl;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 3 - Using scoped observers
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace example3
-{
-    using namespace std;
-    using namespace react;
-
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
-
-    EventSourceT<> trigger = MakeEventSource<D>();
-
-    void Run()
-    {
-        cout << "Example 3 - Using scoped observers" << endl;
-
-        // Inner scope
-        {
-            ScopedObserverT scopedObs
-            (
-                Observe(trigger, [] (Token) {
-                    cout << "Triggered!" << endl;
-                })
-            );
-
-            trigger.Emit(); // output: Triggered!
-        }
-        // ~Inner scope
+        obs.Cancel();   // Remove the observer
 
         trigger.Emit(); // no output
 
-        // Note the semantic difference between ScopedObserverT and ObserverT.
-        //
-        // During its lifetime, the ObserverT handle of an observer guarantees that the
-        // observed subject will not be destroyed and allows explicit detach.
-        // But even after the ObserverT handle is destroyed, the subject may continue to exist
-        // and so will the observer.
-        //
-        // ScopedObserverT has similar semantics to a scoped lock.
-        // When it's destroyed, it detaches and destroys the observer.
-
         cout << endl;
     }
 }
@@ -177,12 +81,8 @@ namespace example3
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    example1::v1::Run();
-    example1::v2::Run();
-
+    example1::Run();
     example2::Run();
 
-    example3::Run();
-
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicReactors.cpp b/examples/src/BasicReactors.cpp
deleted file mode 100644
index 534c1346..00000000
--- a/examples/src/BasicReactors.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include <iostream>
-#include <utility>
-#include <vector>
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Reactor.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 1 - Creating reactive loops
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace example1
-{
-    using namespace std;
-    using namespace react;
-
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
-
-    using PointT = pair<int,int>;
-    using PathT  = vector<PointT>;
-
-    vector<PathT> paths;
-
-    EventSourceT<PointT> mouseDown = MakeEventSource<D,PointT>();
-    EventSourceT<PointT> mouseUp   = MakeEventSource<D,PointT>();
-    EventSourceT<PointT> mouseMove = MakeEventSource<D,PointT>();
-
-    ReactorT loop
-    {
-        [&] (ReactorT::Context ctx)
-        {
-            PathT points;
-
-            points.emplace_back(ctx.Await(mouseDown));
-
-            ctx.RepeatUntil(mouseUp, [&] {
-                points.emplace_back(ctx.Await(mouseMove));
-            });
-
-            points.emplace_back(ctx.Await(mouseUp));
-
-            paths.push_back(points);
-        }
-    };
-
-    void Run()
-    {
-        cout << "Example 1 - Creating reactive loops" << endl;
-
-        mouseDown << PointT( 1,1 );
-        mouseMove << PointT( 2,2 ) << PointT( 3,3 ) << PointT( 4,4 );
-        mouseUp   << PointT( 5,5 );
-
-        mouseMove << PointT( 999,999 );
-
-        mouseDown << PointT( 10,10 );
-        mouseMove << PointT( 20,20 );
-        mouseUp   << PointT( 30,30 );
-
-        for (const auto& path : paths)
-        {
-            cout << "Path: ";
-            for (const auto& point : path)
-                cout << "(" << point.first << "," << point.second << ")   ";
-            cout << endl;
-        }
-
-        cout << endl;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 2 - Creating reactive loops
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace example2
-{
-    using namespace std;
-    using namespace react;
-
-    REACTIVE_DOMAIN(D, sequential)
-    USING_REACTIVE_DOMAIN(D)
-
-    using PointT = pair<int,int>;
-    using PathT  = vector<PointT>;
-
-    vector<PathT> paths;
-
-    EventSourceT<PointT> mouseDown = MakeEventSource<D,PointT>();
-    EventSourceT<PointT> mouseUp   = MakeEventSource<D,PointT>();
-    EventSourceT<PointT> mouseMove = MakeEventSource<D,PointT>();
-
-    VarSignalT<int>      counter   = MakeVar<D>(103);
-
-    ReactorT loop
-    {
-        [&] (ReactorT::Context ctx)
-        {
-            PathT points;
-
-            points.emplace_back(ctx.Await(mouseDown));
-
-            auto count = ctx.Get(counter);
-
-            ctx.RepeatUntil(mouseUp, [&] {
-                points.emplace_back(ctx.Await(mouseMove));
-            });
-
-            points.emplace_back(ctx.Await(mouseUp));
-
-            paths.push_back(points);
-        }
-    };
-
-    void Run()
-    {
-        cout << "Example 2 - Creating reactive loops" << endl;
-
-        mouseDown << PointT( 1,1 );
-        mouseMove << PointT( 2,2 ) << PointT( 3,3 ) << PointT( 4,4 );
-        mouseUp   << PointT( 5,5 );
-
-        counter <<= 42;
-
-        mouseMove << PointT( 999,999 );
-
-        counter <<= 80;
-
-        mouseDown << PointT( 10,10 );
-        mouseMove << PointT( 20,20 );
-        mouseUp   << PointT( 30,30 );
-
-        for (const auto& path : paths)
-        {
-            cout << "Path: ";
-            for (const auto& point : path)
-                cout << "(" << point.first << "," << point.second << ")   ";
-            cout << endl;
-        }
-
-        cout << endl;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Run examples
-///////////////////////////////////////////////////////////////////////////////////////////////////
-int main()
-{
-    example1::Run();
-    example2::Run();
-
-    return 0;
-}
\ No newline at end of file
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index bebdf7bf..3007d199 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -27,8 +27,8 @@ namespace example1
         { return first + string(" ") + second; }
 
     // Defines a group.
-    // Each domain represents a separate dependency graph, managed by a dedicated propagation engine.
-    // Reactives of different domains can not be combined.
+    // Each group represents a separate dependency graph.
+    // Reactives from different groups can not be mixed.
     ReactiveGroup<> group;
     
     // The two words
diff --git a/include/react/API.h b/include/react/API.h
index 68b6f531..435e6562 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -72,19 +72,21 @@ template <typename T, OwnershipPolicy = unique>
 class VarSignal;
 
 // Events
-template <typename T>
+enum class Token;
+
+template <typename E>
 class EventBase;
 
-template <typename T>
+template <typename E>
 class EventSourceBase;
 
-template <typename T, OwnershipPolicy = unique>
+template <typename E = Token, OwnershipPolicy = unique>
 class Event;
 
-template <typename T, OwnershipPolicy = unique>
+template <typename E = Token, OwnershipPolicy = unique>
 class EventSource;
 
-enum class Token;
+
 
 // Observers
 template <OwnershipPolicy = unique>
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index e6624d74..af6bce46 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -28,9 +28,10 @@ auto Hold(T&& initialValue, const EventBase<E>& events) -> Signal<E, unique>
 {
     using REACT_IMPL::HoldNode;
     using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
 
-    return Signal<E, unique>( std::make_shared<HoldNode<T>>(
-        PrivateNodeInterface::GraphPtr(events), std::forward<U>(initialValue), PrivateNodeInterface::NodePtr(events)) );
+    return Signal<E, unique>( NodeCtorTag{ }, std::make_shared<HoldNode<E>>(
+        PrivateNodeInterface::GraphPtr(events), std::forward<T>(initialValue), PrivateNodeInterface::NodePtr(events)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -41,8 +42,9 @@ auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
 {
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
 
-    return Event<S, unique>( std::make_shared<MonitorNode<T>>(
+    return Event<S, unique>( NodeCtorTag{ }, std::make_shared<MonitorNode<S>>(
         PrivateNodeInterface::GraphPtr(signal), PrivateNodeInterface::NodePtr(signal)) );
 }
 
@@ -50,121 +52,46 @@ auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
 /// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E>
-auto Iterate(T&& init, F&& func, const Events<E>& events) -> Signal<S, unique>
+auto Iterate(T&& init, F&& func, const EventBase<E>& events) -> Signal<S, unique>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
-    using REACT_IMPL::AddIterateRangeWrapper;
-    using REACT_IMPL::AddIterateByRefRangeWrapper;
     using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::EventRange;
-
-    using TFunc = typename std::decay<F>::type;
-
-    using NodeT =
-        typename std::conditional<
-            IsCallableWith<F,S,EventRange<E>,S>::value,
-            IterateNode<D,S,E,F>,
-            typename std::conditional<
-                IsCallableWith<F,S,E,S>::value,
-                IterateNode<D,S,E,AddIterateRangeWrapper<E,S,F>>,
-                typename std::conditional<
-                    IsCallableWith<F, void, EventRange<E>, S&>::value,
-                    IterateByRefNode<D,S,E,F>,
-                    typename std::conditional<
-                        IsCallableWith<F,void,E,S&>::value,
-                        IterateByRefNode<D,S,E,AddIterateByRefRangeWrapper<E,S,F>>,
-                        void
-                    >::type
-                >::type
-            >::type
-        >::type;
-
-    static_assert(
-        ! std::is_same<NodeT,void>::value,
-        "Iterate: Passed function does not match any of the supported signatures.");
-
-    return Signal<S>(
-        std::make_shared<NodeT>(
-            std::forward<V>(init), GetNodePtr(events), std::forward<FIn>(func)));
+    using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
+
+    using FuncType = typename std::decay<F>::type;
+    using IterNodeType = typename std::conditional<
+        IsCallableWith<F,S,EventRange<E>,S>::value,
+        IterateNode<S, FuncType, E>,
+        IterateByRefNode<S, FuncType, E>>::type;
+
+    return Signal<S, unique>( NodeCtorTag{ }, std::make_shared<IterNodeType>(
+        PrivateNodeInterface::GraphPtr(events), std::forward<T>(init), std::forward<F>(func), PrivateNodeInterface::NodePtr(events) ));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename S,
-    typename E,
-    typename V,
-    typename FIn,
-    typename ... TDepValues
->
-auto Iterate(const Events<E>& events, V&& init, const SignalPack<TDepValues...>& depPack, FIn&& func) -> Signal<S>
+template <typename S, typename T, typename F, typename E, typename ... Us>
+auto Iterate(T&& init, F&& func, const EventBase<E>& events, const SignalBase<Us>& ... signals) -> Signal<S, unique>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
-    using REACT_IMPL::AddIterateRangeWrapper;
-    using REACT_IMPL::AddIterateByRefRangeWrapper;
     using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::EventRange;
-
-    using F = typename std::decay<FIn>::type;
-
-    using NodeT =
-        typename std::conditional<
-            IsCallableWith<F,S,EventRange<E>,S,TDepValues ...>::value,
-            SyncedIterateNode<D,S,E,F,TDepValues ...>,
-            typename std::conditional<
-                IsCallableWith<F,S,E,S,TDepValues ...>::value,
-                SyncedIterateNode<D,S,E,
-                    AddIterateRangeWrapper<E,S,F,TDepValues ...>,
-                    TDepValues ...>,
-                typename std::conditional<
-                    IsCallableWith<F,void,EventRange<E>,S&,TDepValues ...>::value,
-                    SyncedIterateByRefNode<D,S,E,F,TDepValues ...>,
-                    typename std::conditional<
-                        IsCallableWith<F,void,E,S&,TDepValues ...>::value,
-                        SyncedIterateByRefNode<D,S,E,
-                            AddIterateByRefRangeWrapper<E,S,F,TDepValues ...>,
-                            TDepValues ...>,
-                        void
-                    >::type
-                >::type
-            >::type
-        >::type;
-
-    static_assert(
-        ! std::is_same<NodeT,void>::value,
-        "Iterate: Passed function does not match any of the supported signatures.");
-
-    //static_assert(NodeT::dummy_error, "DUMP MY TYPE" );
-
-    struct NodeBuilder_
-    {
-        NodeBuilder_(const Events<D,E>& source, V&& init, FIn&& func) :
-            MySource( source ),
-            MyInit( std::forward<V>(init) ),
-            MyFunc( std::forward<FIn>(func) )
-        {}
-
-        auto operator()(const Signal<D,TDepValues>& ... deps)
-            -> Signal<D,S>
-        {
-            return Signal<D,S>(
-                std::make_shared<NodeT>(
-                    std::forward<V>(MyInit), GetNodePtr(MySource),
-                    std::forward<FIn>(MyFunc), GetNodePtr(deps) ...));
-        }
-
-        const Events<D,E>&  MySource;
-        V                   MyInit;
-        FIn                 MyFunc;
-    };
-
-    return REACT_IMPL::apply(
-        NodeBuilder_( events, std::forward<V>(init), std::forward<FIn>(func) ),
-        depPack.Data);
+    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
+
+    using FuncType = typename std::decay<F>::type;
+    using IterNodeType = typename std::conditional<
+        IsCallableWith<F, S, EventRange<E>, S, Us ...>::value,
+        SyncedIterateNode<S, FuncType, E, Us ...>,
+        SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
+
+    return Signal<S, unique>( NodeCtorTag{ }, std::make_shared<IterNodeType>(
+        GetCheckedGraphPtr(events, signals ...),
+        std::forward<T>(init), std::forward<F>(func), PrivateNodeInterface::NodePtr(events), PrivateNodeInterface::NodePtr(signals) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -176,8 +103,9 @@ auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& trigger) -> Signa
     using REACT_IMPL::SnapshotNode;
     using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
 
-    return Events<S, unique>( std::make_shared<SnapshotNode<S, E>>(
+    return Events<S, unique>( NodeCtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
         GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
 }
 
@@ -191,7 +119,7 @@ auto Pulse(const SignalBase<S>& signal, const EventBase<E>& trigger) -> Event<S,
     using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
 
-    return Event<S, unique>( std::make_shared<PulseNode<S, E>>(
+    return Event<S, unique>( NodeCtorTag{ }, std::make_shared<PulseNode<S, E>>(
         GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
 }
 
diff --git a/include/react/Event.h b/include/react/Event.h
index 637268ff..13fdcb5c 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -31,8 +31,8 @@ class EventBase
     using NodeType = REACT_IMPL::EventStreamNode<E>;
 
 public:
-    // Node ctor
-    explicit EventBase(std::shared_ptr<NodeType>&& nodePtr) :
+    // Private node ctor
+    EventBase(REACT_IMPL::NodeCtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
         { }
 
@@ -176,12 +176,12 @@ class Event<E, unique> : public EventBase<E>
 
     template <typename F, typename T>
     Event(F&& func, const EventBase<T>& dep) :
-        Event::EventBase( CreateProcessingNode(std::forward<F>(func), dep) )
+        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T, typename ... Us>
     Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
         { }
 };
 
@@ -210,12 +210,12 @@ class Event<E, shared> : public EventBase<E>
 
     template <typename F, typename T>
     Event(F&& func, const EventBase<T>& dep) :
-        Event::EventBase( CreateProcessingNode(std::forward<F>(func), dep) )
+        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T, typename ... Us>
     Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( SyncedCreateProcessingNode(std::forward<F>(func), dep, signals ...) )
+        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
         { }
 };
 
@@ -241,7 +241,7 @@ class EventSource<E, unique> : public EventSourceBase<E>
     // Construct event source
     template <typename TGroup>
     explicit EventSource(const TGroup& group) :
-        EventSource::EventSourceBase( CreateSourceNode(group) )
+        EventSource::EventSourceBase( REACT_IMPL::NodeCtorTag{ }, CreateSourceNode(group) )
         { }
 };
 
@@ -264,7 +264,7 @@ class EventSource<E, shared> : public EventSourceBase<E>
     // Construct event source
     template <typename TGroup>
     explicit EventSource(const TGroup& group) :
-        EventSource::EventSourceBase( CreateSourceNode(group) )
+        EventSource::EventSourceBase( REACT_IMPL::NodeCtorTag{ }, CreateSourceNode(group) )
         { }
 
     // Construct from unique
@@ -286,6 +286,7 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
 
     static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
 
@@ -297,8 +298,8 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
 
     const auto& graphPtr = GetCheckedGraphPtr(dep1, deps ...);
 
-    return Event<E, unique>(
-        std::make_shared<EventMergeNode<E, U1, Us ...>>(graphPtr, PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...));
+    return Event<E, unique>( NodeCtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
+        graphPtr, PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -370,14 +371,15 @@ auto Join(const EventBase<Ts>& ... deps) -> Event<std::tuple<Ts ...>, unique>
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::NodeCtorTag;
 
     static_assert(sizeof...(Ts) > 1, "Join requires at least 2 inputs.");
 
     // If supplied, use merge type, otherwise default to common type.
     const auto& graphPtr = GetCheckedGraphPtr(deps ...);
 
-    return Event<std::tuple<Ts ...>, unique>(
-        std::make_shared<EventJoinNode<Ts ...>>(graphPtr, PrivateNodeInterface::NodePtr(deps) ...));
+    return Event<std::tuple<Ts ...>, unique>( NodeCtorTag{ }, std::make_shared<EventJoinNode<Ts ...>>(
+        graphPtr, PrivateNodeInterface::NodePtr(deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Group.h b/include/react/Group.h
index 71434d1e..c8324d1c 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -15,8 +15,6 @@
 #include <utility>
 
 #include "react/API.h"
-#include "react/Signal.h"
-//#include "react/Event.h"
 
 #include "react/detail/IReactiveGraph.h"
 #include "react/detail/graph/PropagationST.h"
@@ -25,6 +23,7 @@
 
 struct PrivateReactiveGroupInterface;
 struct PrivateConcurrentReactiveGroupInterface;
+struct NodeCtorTag { };
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
diff --git a/include/react/Signal.h b/include/react/Signal.h
index c46a0b94..22e4e548 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -37,7 +37,7 @@ class SignalBase
 
 public:
     // Private node ctor
-    explicit SignalBase(std::shared_ptr<NodeType>&& nodePtr) :
+    SignalBase(REACT_IMPL::NodeCtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
         { }
 
@@ -181,8 +181,8 @@ class Signal<S, unique> : public SignalBase<S>
 
     // Construct func signal
     template <typename F, typename ... Ts>
-    Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
+    explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::NodeCtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
         { }
 };
 
@@ -204,8 +204,8 @@ class Signal<S, shared> : public SignalBase<S>
 
     // Construct func signal
     template <typename F, typename ... Ts>
-    Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( CreateFuncNode(std::forward<F>(func), deps ...) )
+    explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::NodeCtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
         { }
 
     // Construct from unique
@@ -240,13 +240,13 @@ class VarSignal<S, unique> : public VarSignalBase<S>
     // Construct with default
     template <typename TGroup>
     explicit VarSignal(const TGroup& group) :
-        VarSignal::VarSignalBase( CreateVarNode( group) )
+        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode( group) )
         { }
 
     // Construct with value
     template <typename T, typename TGroup>
     VarSignal(T&& value, const TGroup& group) :
-        VarSignal::VarSignalBase( CreateVarNode(std::forward<T>(value), group) )
+        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode(std::forward<T>(value), group) )
         { }
 };
 
@@ -278,13 +278,13 @@ class VarSignal<S, shared> : public VarSignalBase<S>
     // Construct with default
     template <typename TGroup>
     explicit VarSignal(const TGroup& group) :
-        VarSignal::VarSignalBase( CreateVarNode( group) )
+        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode( group) )
         { }
 
     // Construct with value
     template <typename T, typename TGroup>
     VarSignal(T&& value, const TGroup& group) :
-        VarSignal::VarSignalBase( CreateVarNode(std::forward<T>(value), group) )
+        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode(std::forward<T>(value), group) )
         { }
 };
 
diff --git a/include/react/common/Util.h b/include/react/common/Util.h
index 741cd61d..4721723d 100644
--- a/include/react/common/Util.h
+++ b/include/react/common/Util.h
@@ -216,6 +216,12 @@ class IsCallableWith
     static const bool value = sizeof(check<F>(nullptr)) == sizeof(YesT);
 };
 
+template <typename T>
+bool IsBitmaskSet(T flags, T mask)
+{
+    return (flags & mask) != (T)0;
+}
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 // Expand args by wrapping them in a dummy function
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/IReactiveGraph.h
index ddb29689..4cf87bf0 100644
--- a/include/react/detail/IReactiveGraph.h
+++ b/include/react/detail/IReactiveGraph.h
@@ -37,6 +37,16 @@ enum class UpdateResult
     shifted
 };
 
+enum class NodeFlags
+{
+    none,
+    input,
+    output,
+    dynamic,
+    buffered
+};
+REACT_DEFINE_BITMASK_OPERATORS(NodeFlags)
+
 struct IReactiveGraph;
 struct IReactiveNode;
 
@@ -47,7 +57,7 @@ struct IReactiveGraph
 {
     virtual ~IReactiveGraph() = default;
 
-    virtual NodeId RegisterNode(IReactiveNode* nodePtr) = 0;
+    virtual NodeId RegisterNode(IReactiveNode* nodePtr, NodeFlags flags) = 0;
     virtual void UnregisterNode(NodeId node) = 0;
 
     virtual void OnNodeAttach(NodeId nodeId, NodeId parentId) = 0;
@@ -66,33 +76,13 @@ struct IReactiveNode
 {
     virtual ~IReactiveNode() = default;
 
-    /// Returns unique type identifier
     virtual const char* GetNodeType() const = 0;
 
-    // Note: Could get rid of this ugly ptr by adding a template parameter to the interface
-    // But that would mean all engine nodes need that template parameter too - so rather cast
     virtual UpdateResult Update(TurnId turnId) = 0;  
 
-    /// Input nodes can be manipulated externally.
-    virtual bool IsInputNode() const = 0;
-
-    /// Output nodes can't have any successors.
-    virtual bool IsOutputNode() const = 0;
-
-    /// Dynamic nodes may change in topology as a result of tick.
-    virtual bool IsDynamicNode() const = 0;
-
-    // Number of predecessors.
     virtual int GetDependencyCount() const = 0;
-};
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EPropagationMode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum EPropagationMode
-{
-    sequential_propagation,
-    parallel_propagation
+    virtual void ClearBuffer() = 0;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index e3b8d584..6d696532 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -81,15 +81,15 @@ struct AddIterateByRefRangeWrapper
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S, typename E, typename F>
+template <typename S, typename F, typename E>
 class IterateNode : public SignalNode<S>
 {
 public:
-    template <typename U, typename V>
-    IterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, U&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func) :
-        IterateNode::SignalNode( graphPtr, std::forward<U>(init) ),
-        events_( events ),
-        func_( std::forward<FIn>(func) )
+    template <typename T, typename FIn>
+    IterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
+        IterateNode::SignalNode( graphPtr, std::forward<T>(init) ),
+        func_( std::forward<FIn>(func) ),
+        events_( events )
     {
         this->RegisterMe();
         this->AttachToMe(events->GetNodeId());
@@ -105,7 +105,7 @@ class IterateNode : public SignalNode<S>
     {
         S newValue = func_(EventRange<E>( events_->Events() ), this->Value());
 
-        if (! Equals(newValue, this->Value()))
+        if (! (newValue == this->Value()))
         {
             this->Value() = std::move(newValue);
             return UpdateResult::changed;
@@ -125,19 +125,19 @@ class IterateNode : public SignalNode<S>
 private:
     std::shared_ptr<EventStreamNode<E>> events_;
     
-    F   func_;
+    F func_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IterateByRefNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S, typename E, typename F>
+template <typename S, typename F, typename E>
 class IterateByRefNode : public SignalNode<S>
 {
 public:
-    template <typename SIn, typename FIn>
-    IterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, SIn&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func) :
-        IterateByRefNode::SignalNode( graphPtr, std::forward<SIn>(init) ),
+    template <typename T, typename FIn>
+    IterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
+        IterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events )
     {
@@ -174,33 +174,31 @@ class IterateByRefNode : public SignalNode<S>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedIterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S, typename E, typename F, typename ... TSyncs>
+template <typename S, typename F, typename E, typename ... TSyncs>
 class SyncedIterateNode : public SignalNode<S>
 {
 public:
-    template <typename SIn, typename FIn>
-    SyncedIterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, SIn&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedIterateNode::SignalNode( graphPtr, std::forward<SIn>(init) ),
-        events_( events ),
+    template <typename T, typename FIn>
+    SyncedIterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+        SyncedIterateNode::SignalNode( graphPtr, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
+        events_( events ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
+        this->AttachToMe(events->GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedIterateNode()
     {
         apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(dep_->GetNodeId());
+        this->DetachFromMe(events_->GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        events_->SetCurrentTurn(turn);
-
         S newValue = apply(
             [this] (const auto& ... syncs)
             {
@@ -208,7 +206,7 @@ class SyncedIterateNode : public SignalNode<S>
             },
             syncHolder_);
 
-        if (! Equals(newValue, this->Value()))
+        if (! (newValue == this->Value()))
         {
             this->Value() = std::move(newValue);
             return UpdateResult::changed;
@@ -226,42 +224,42 @@ class SyncedIterateNode : public SignalNode<S>
         { return 1 + sizeof...(TSyncs); }
 
 private:
-    std::shared_ptr<EventStreamNode<E>> events_;
-    
     F func_;
 
+    std::shared_ptr<EventStreamNode<E>> events_;
+
     std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedIterateByRefNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S, typename E, typename TFunc, typename ... TSyncs>
+template <typename S, typename F, typename E, typename ... TSyncs>
 class SyncedIterateByRefNode : public SignalNode<S>
 {
 public:
-    template <typename SIn, typename FIn>
-    SyncedIterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, SIn&& init, const std::shared_ptr<EventStreamNode<E>>& events, FIn&& func, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+    template <typename T, typename FIn>
+    SyncedIterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
         SyncedIterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
-        events_( events ),
         func_( std::forward<FIn>(func) ),
+        events_( events ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
+        this->AttachToMe(events->GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
 
     ~SyncedIterateByRefNode()
     {
         apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(dep_->GetNodeId());
+        this->DetachFromMe(events_->GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        events_->SetCurrentTurn(turn);
+        events_->SetCurrentTurn(turnId);
 
         bool changed = false;
 
@@ -272,7 +270,7 @@ class SyncedIterateByRefNode : public SignalNode<S>
                 {
                     func_(EventRange<E>( events_->Events() ), this->Value(), args->Value() ...);
                 },
-                deps_);
+                syncHolder_);
 
             return UpdateResult::changed;
         }
@@ -289,23 +287,23 @@ class SyncedIterateByRefNode : public SignalNode<S>
         { return 1 + sizeof...(TSyncs); }
 
 private:
-    std::shared_ptr<EventStreamNode<E>> events_;
-    
     F func_;
 
+    std::shared_ptr<EventStreamNode<E>> events_;
+
     std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// HoldNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class HoldNode : public SignalNode<T>
+template <typename S>
+class HoldNode : public SignalNode<S>
 {
 public:
-    template <typename TIn>
-    HoldNode(const std::shared_ptr<IReactiveGraph>& graphPtr, TIn&& init, const std::shared_ptr<EventStreamNode<T>>& events) :
-        HoldNode::SignalNode( graphPtr, std::forward<TIn>(init) ),
+    template <typename T>
+    HoldNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, const std::shared_ptr<EventStreamNode<S>>& events) :
+        HoldNode::SignalNode( graphPtr, std::forward<T>(init) ),
         events_( events )
     {
         this->RegisterMe();
@@ -329,7 +327,7 @@ class HoldNode : public SignalNode<T>
         {
             const S& newValue = events_->Events().back();
 
-            if (! Equals(newValue, this->Value()))
+            if (! (newValue == this->Value()))
             {
                 changed = true;
                 this->Value() = newValue;
@@ -410,11 +408,11 @@ class SnapshotNode : public SignalNode<S>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// MonitorNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class MonitorNode : public EventStreamNode<T>
+template <typename S>
+class MonitorNode : public EventStreamNode<S>
 {
 public:
-    MonitorNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<T>>& target) :
+    MonitorNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target) :
         MonitorNode::EventStreamNode( graphPtr ),
         target_( target )
     {
@@ -430,7 +428,7 @@ class MonitorNode : public EventStreamNode<T>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turn, true);
+        this->SetCurrentTurn(turnId, true);
 
         this->Events().push_back(target_->Value());
 
@@ -444,7 +442,7 @@ class MonitorNode : public EventStreamNode<T>
         { return 1; }
 
 private:
-    std::shared_ptr<SignalNode<E>>    target_;
+    std::shared_ptr<SignalNode<S>>    target_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index bd966944..caf2e049 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -27,7 +27,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterators for event processing
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
+template <typename T = Token>
 class EventRange
 {
 public:
@@ -87,33 +87,21 @@ class EventStreamNode : public NodeBase
     EventStreamNode(const EventStreamNode&) = delete;
     EventStreamNode& operator=(const EventStreamNode&) = delete;
 
-    void SetCurrentTurn(TurnId turnId, bool forceUpdate = false, bool noClear = false)
-    {
-        //this->AccessBufferForClearing([&] {
-        //    if (curTurnId_ != turn.Id() || forceUpdate)
-        //    {
-        //        curTurnId_ =  turn.Id();
-        //        if (!noClear)
-        //            events_.clear();
-        //    }
-        //});
-    }
-
     explicit EventStreamNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
         NodeBase( graphPtr )
         { }
 
-    StorageType&  Events()
+    StorageType& Events()
         { return events_; }
 
-    const StorageType&  Events() const
+    const StorageType& Events() const
         { return events_; }
 
-protected:
-    StorageType events_;
+    virtual void ClearBuffer() override
+        { events_.clear(); };
 
 private:
-    uint curTurnId_ { (std::numeric_limits<uint>::max)() };
+    StorageType events_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -125,7 +113,7 @@ class EventSourceNode : public EventStreamNode<T>
 public:
     EventSourceNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
         EventSourceNode::EventStreamNode( graphPtr )
-        { this->RegisterMe(); }
+        { this->RegisterMe(NodeFlags::buffered | NodeFlags::input); }
 
     ~EventSourceNode()
         { this->UnregisterMe(); }
@@ -133,19 +121,13 @@ class EventSourceNode : public EventStreamNode<T>
     virtual const char* GetNodeType() const override
         { return "EventSource"; }
 
-    virtual bool IsInputNode() const override
-        { return true; }
-
     virtual int GetDependencyCount() const override
         { return 0; }
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        if (this->Events().size() > 0 && !changedFlag_)
-        {
-            this->SetCurrentTurn(turnId, true, true);
-            changedFlag_ = true;
-            
+        if (this->Events().size() > 0)
+        {            
             return UpdateResult::changed;
         }
         else
@@ -157,18 +139,8 @@ class EventSourceNode : public EventStreamNode<T>
     template <typename U>
     void EmitValue(U&& value)
     {
-        // Clear input from previous turn
-        if (changedFlag_)
-        {
-            changedFlag_ = false;
-            this->Events().clear();
-        }
-
         this->Events().push_back(std::forward<U>(value));
     }
-
-private:
-    bool changedFlag_ = false;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -182,7 +154,7 @@ class EventMergeNode : public EventStreamNode<TOut>
         EventMergeNode::EventStreamNode( graphPtr ),
         depHolder_( deps ... )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered);
         REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
@@ -194,8 +166,6 @@ class EventMergeNode : public EventStreamNode<TOut>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turnId, true);
-
         apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
         if (! this->Events().empty())
@@ -214,7 +184,6 @@ class EventMergeNode : public EventStreamNode<TOut>
     template <typename U>
     void MergeFromDep(const std::shared_ptr<EventStreamNode<U>>& other)
     {
-        //arg->SetCurrentTurn(turn);
         this->Events().insert(this->Events().end(), other->Events().begin(), other->Events().end());
     }
 
@@ -233,7 +202,7 @@ class EventFlattenNode : public EventStreamNode<TInner>
         outer_( outer ),
         inner_( inner )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered | NodeFlags::dynamic);
         this->AttachToMe(outer->GetNodeId());
         this->AttachToMe(inner->GetNodeId());
     }
@@ -248,17 +217,11 @@ class EventFlattenNode : public EventStreamNode<TInner>
     virtual const char* GetNodeType() const override
         { return "EventFlatten"; }
 
-    virtual bool IsDynamicNode() const override
-        { return true; }
-
     virtual int GetDependencyCount() const override
         { return 2; }
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turnId, true);
-        inner_->SetCurrentTurn(turnId);
-
         auto newInner = GetNodePtr(outer_->Value());
 
         if (newInner != inner_)
@@ -301,7 +264,7 @@ class EventProcessingNode : public EventStreamNode<TOut>
         func_( std::forward<FIn>(func) ),
         dep_( dep )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered);
         this->AttachToMe(dep->GetNodeId());
     }
 
@@ -313,8 +276,6 @@ class EventProcessingNode : public EventStreamNode<TOut>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turnId, true);
-
         func_(EventRange<TIn>( dep_->Events() ), std::back_inserter(this->Events()));
 
         if (! this->Events().empty())
@@ -349,7 +310,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         dep_( dep ),
         syncHolder_( syncs ... )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered);
         this->AttachToMe(dep->GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
@@ -363,10 +324,9 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turnId, true);
-        // Update of this node could be triggered from deps,
-        // so make sure source doesnt contain events from last turn
-        dep_->SetCurrentTurn(turnId);
+        // Updates might be triggered even if only sync nodes changed. Ignore those.
+        if (dep_->Events().empty())
+            return UpdateResult::unchanged;
 
         apply(
             [this] (const auto& ... syncs)
@@ -406,7 +366,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         EventJoinNode::EventStreamNode( graphPtr ),
         slots_( deps ... )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered);
         REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
@@ -418,8 +378,6 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turnId, true);
-
         // Move events into buffers
         apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
 
@@ -429,7 +387,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 
             // All slots ready?
             apply(
-                [this,&isReady] (Slot<Ts>& ... slots) {
+                [this, &isReady] (Slot<Ts>& ... slots) {
                     // Todo: combine return values instead
                     REACT_EXPAND_PACK(CheckSlot(slots, isReady));
                 },
@@ -475,7 +433,6 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     template <typename U>
     static void FetchBuffer(TurnId turnId, Slot<U>& slot)
     {
-        slot.source->SetCurrentTurn(turnId);
         slot.buffer.insert(slot.buffer.end(), slot.source->Events().begin(), slot.source->Events().end());
     }
 
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index b694e34e..8466d77b 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -38,15 +38,6 @@ class NodeBase : public IReactiveNode
 
     NodeBase(NodeBase&&) = delete;
     NodeBase& operator=(NodeBase&&) = delete;
-    
-    virtual bool IsInputNode() const override
-        { return false; }
-
-    virtual bool IsOutputNode() const override
-        { return false; }
-
-    virtual bool IsDynamicNode() const override
-        { return false; }
 
     /*void SetWeightHint(WeightHint weight)
     {
@@ -74,8 +65,8 @@ class NodeBase : public IReactiveNode
         { return graphPtr_; }
 
 protected:
-    void RegisterMe()
-        { nodeId_ = graphPtr_->RegisterNode(this); }
+    void RegisterMe(NodeFlags flags = NodeFlags::none)
+        { nodeId_ = graphPtr_->RegisterNode(this, flags); }
     
     void UnregisterMe()
         { graphPtr_->UnregisterNode(nodeId_); }
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index 0713c157..abdf1c6e 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -39,8 +39,8 @@ class ObserverNode : public NodeBase
         ObserverNode::NodeBase( graphPtr )
         { }
 
-    virtual bool IsOutputNode() const
-        { return true; }
+    virtual void ClearBuffer() override
+        { };
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -56,7 +56,7 @@ class SignalObserverNode : public ObserverNode
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::output);
         REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
@@ -97,7 +97,7 @@ class EventObserverNode : public ObserverNode
         func_( std::forward<FIn>(func) ),
         subject_( subject )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::output);
         this->AttachToMe(subject->GetNodeId());
     }
 
@@ -139,7 +139,7 @@ class SyncedEventObserverNode : public ObserverNode
         subject_( subject ),
         syncHolder_( syncs ... )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::output);
         this->AttachToMe(subject->GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index bfbc0828..863df8e5 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -26,7 +26,7 @@ class SingleThreadedGraph : public IReactiveGraph
 {
 public:
     // IReactiveGraph
-    virtual NodeId RegisterNode(IReactiveNode* nodePtr) override;
+    virtual NodeId RegisterNode(IReactiveNode* nodePtr, NodeFlags flags) override;
     virtual void UnregisterNode(NodeId node) override;
 
     virtual void OnNodeAttach(NodeId node, NodeId parentId) override;
@@ -49,15 +49,19 @@ class SingleThreadedGraph : public IReactiveGraph
         NodeData(const NodeData&) = default;
         NodeData& operator=(const NodeData&) = default;
 
-        NodeData(IReactiveNode* nodePtrIn) :
-            nodePtr( nodePtrIn )
+        NodeData(IReactiveNode* nodePtrIn, NodeFlags flagsIn) :
+            nodePtr( nodePtrIn ),
+            flags( flagsIn )
         { }
 
+        NodeFlags flags = NodeFlags::none;
+
         int     level       = 0;
         int     newLevel    = 0 ;
         bool    queued      = false;
 
         IReactiveNode*  nodePtr = nullptr;
+        
 
         std::vector<NodeId> successors;
     };
@@ -89,6 +93,7 @@ class SingleThreadedGraph : public IReactiveGraph
 
     void ScheduleSuccessors(NodeData & node);
     void InvalidateSuccessors(NodeData & node);
+    void ClearBufferedNodes();
 
 private:
     int refCount_ = 1;
@@ -97,12 +102,14 @@ class SingleThreadedGraph : public IReactiveGraph
     IndexMap<NodeData>  nodeData_;
     std::vector<NodeId> changedInputs_;
 
+    std::vector<IReactiveNode*> pendingBufferedNodes_;
+
     bool isTransactionActive_ = false;
 };
 
-NodeId SingleThreadedGraph::RegisterNode(IReactiveNode* nodePtr)
+NodeId SingleThreadedGraph::RegisterNode(IReactiveNode* nodePtr, NodeFlags flags)
 {
-    return nodeData_.Insert(NodeData{ nodePtr });
+    return nodeData_.Insert(NodeData{ nodePtr, flags });
 }
 
 void SingleThreadedGraph::UnregisterNode(NodeId nodeId)
@@ -159,12 +166,17 @@ void SingleThreadedGraph::AddInput(NodeId nodeId, std::function<void()> inputCal
         // Update the node. This applies the input buffer to the node value and checks if it changed.
         if (nodePtr->Update(0) == UpdateResult::changed)
         {
+            if (IsBitmaskSet(node.flags, NodeFlags::buffered))
+                pendingBufferedNodes_.push_back(nodePtr);
+
             // Propagate changes through the graph
             ScheduleSuccessors(node);
 
             if (! scheduledNodes_.IsEmpty())
                 Propagate();
-        }       
+        }
+
+        ClearBufferedNodes();
     }
 }
 
@@ -180,9 +192,15 @@ void SingleThreadedGraph::DoTransaction(TransactionFlags flags, F&& transactionC
     for (NodeId nodeId : changedInputs_)
     {
         auto& node = nodeData_[nodeId];
+        auto* nodePtr = node.nodePtr;
+
+        if (nodePtr->Update(0) == UpdateResult::changed)
+        {
+            if (IsBitmaskSet(node.flags, NodeFlags::buffered))
+                pendingBufferedNodes_.push_back(nodePtr);
 
-        if (node.nodePtr->Update(0) == UpdateResult::changed)
             ScheduleSuccessors(node);
+        }
     }
 
     changedInputs_.clear();
@@ -199,6 +217,7 @@ void SingleThreadedGraph::Propagate()
         for (NodeId nodeId : scheduledNodes_.Next())
         {
             auto& node = nodeData_[nodeId];
+            auto* nodePtr = node.nodePtr;
 
             if (node.level < node.newLevel)
             {
@@ -209,10 +228,13 @@ void SingleThreadedGraph::Propagate()
                 continue;
             }
 
-            auto result = node.nodePtr->Update(0);
+            auto result = nodePtr->Update(0);
 
             if (result == UpdateResult::changed)
             {
+                if (IsBitmaskSet(node.flags, NodeFlags::buffered))
+                    pendingBufferedNodes_.push_back(nodePtr);
+
                 ScheduleSuccessors(node);
             }
             else if (result == UpdateResult::shifted)
@@ -253,6 +275,13 @@ void SingleThreadedGraph::InvalidateSuccessors(NodeData& node)
     }
 }
 
+void SingleThreadedGraph::ClearBufferedNodes()
+{
+    for (IReactiveNode* nodePtr : pendingBufferedNodes_)
+        nodePtr->ClearBuffer();
+    pendingBufferedNodes_.clear();
+}
+
 bool SingleThreadedGraph::TopoQueue::FetchNext()
 {
     // Throw away previous values
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index d45366e1..30128a3e 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -54,6 +54,9 @@ class SignalNode : public NodeBase
     const S& Value() const
         { return value_; }
 
+    virtual void ClearBuffer() override
+        { };
+
 private:
     S value_;
 };
@@ -68,7 +71,7 @@ class VarSignalNode : public SignalNode<S>
     explicit VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
         VarSignalNode::SignalNode( graphPtr ),
         newValue_( )
-        { this->RegisterMe(); }
+        { this->RegisterMe(NodeFlags::input); }
 
     template <typename T>
     VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& value) :
@@ -82,9 +85,6 @@ class VarSignalNode : public SignalNode<S>
     virtual const char* GetNodeType() const override
         { return "VarSignal"; }
 
-    virtual bool IsInputNode() const override
-        { return true; }
-
     virtual int GetDependencyCount() const override
         { return 0; }
 
@@ -219,7 +219,7 @@ class SignalFlattenNode : public SignalNode<TInner>
         outer_( outer ),
         inner_( inner )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::dynamic);
         this->AttachToMe(outer->GetNodeId());
         this->AttachToMe(inner->GetNodeId());
     }
@@ -234,9 +234,6 @@ class SignalFlattenNode : public SignalNode<TInner>
     virtual const char* GetNodeType() const override
         { return "SignalFlatten"; }
 
-    virtual bool IsDynamicNode() const override
-        { return true; }
-
     virtual int GetDependencyCount() const override
         { return 2; }
 
diff --git a/project/msvc/CppReact.sln b/project/msvc/CppReact.sln
index b414852d..bd00b26a 100644
--- a/project/msvc/CppReact.sln
+++ b/project/msvc/CppReact.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.30501.0
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CppReact", "CppReact.vcxproj", "{5E56AAB9-4E33-4B9E-A315-E85CEDB75CF1}"
 EndProject
@@ -27,8 +27,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicEvents", "Exam
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicObservers", "Example_BasicObservers.vcxproj", "{CC66BFA0-D609-46E0-9FD1-F9CC902410B1}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicReactors", "Example_BasicReactors.vcxproj", "{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicSignals", "Example_BasicSignals.vcxproj", "{230C9137-CCD0-47E2-8F1F-2E1DD19984A1}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicSynchronization", "Example_BasicSynchronization.vcxproj", "{269329F8-A9E1-41AC-9C37-3A82A082A62C}"
@@ -105,14 +103,6 @@ Global
 		{CC66BFA0-D609-46E0-9FD1-F9CC902410B1}.Release|Win32.Build.0 = Release|Win32
 		{CC66BFA0-D609-46E0-9FD1-F9CC902410B1}.Release|x64.ActiveCfg = Release|x64
 		{CC66BFA0-D609-46E0-9FD1-F9CC902410B1}.Release|x64.Build.0 = Release|x64
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Debug|Win32.ActiveCfg = Debug|Win32
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Debug|Win32.Build.0 = Debug|Win32
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Debug|x64.ActiveCfg = Debug|x64
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Debug|x64.Build.0 = Debug|x64
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Release|Win32.ActiveCfg = Release|Win32
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Release|Win32.Build.0 = Release|Win32
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Release|x64.ActiveCfg = Release|x64
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96}.Release|x64.Build.0 = Release|x64
 		{230C9137-CCD0-47E2-8F1F-2E1DD19984A1}.Debug|Win32.ActiveCfg = Debug|Win32
 		{230C9137-CCD0-47E2-8F1F-2E1DD19984A1}.Debug|Win32.Build.0 = Debug|Win32
 		{230C9137-CCD0-47E2-8F1F-2E1DD19984A1}.Debug|x64.ActiveCfg = Debug|x64
@@ -142,7 +132,6 @@ Global
 		{D7B70D3B-F14D-4A85-B164-EAB88C358E85} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{BD777649-97F1-4810-BF21-CB27F7672BF4} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{CC66BFA0-D609-46E0-9FD1-F9CC902410B1} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
-		{D976F4D4-B472-4709-BFB5-B1BEEA1F7E96} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{230C9137-CCD0-47E2-8F1F-2E1DD19984A1} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{269329F8-A9E1-41AC-9C37-3A82A082A62C} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 	EndGlobalSection
diff --git a/project/msvc/Example_BasicReactors.vcxproj b/project/msvc/Example_BasicReactors.vcxproj
index ba7b1dad..247db825 100644
--- a/project/msvc/Example_BasicReactors.vcxproj
+++ b/project/msvc/Example_BasicReactors.vcxproj
@@ -136,9 +136,6 @@
       <OptimizeReferences>true</OptimizeReferences>
     </Link>
   </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\examples\src\BasicReactors.cpp" />
-  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="CppReact.vcxproj">
       <Project>{5e56aab9-4e33-4b9e-a315-e85cedb75cf1}</Project>
diff --git a/project/msvc/Example_BasicReactors.vcxproj.filters b/project/msvc/Example_BasicReactors.vcxproj.filters
index 7398067f..6a1782f7 100644
--- a/project/msvc/Example_BasicReactors.vcxproj.filters
+++ b/project/msvc/Example_BasicReactors.vcxproj.filters
@@ -14,9 +14,4 @@
       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
     </Filter>
   </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\examples\src\BasicReactors.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
 </Project>
\ No newline at end of file

From 1fc56425a7ea44b4cbbb618974ff2b1e76fe7d12 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 8 Aug 2016 23:25:30 +0200
Subject: [PATCH 34/75] Fixes.

---
 include/react/API.h                         |  2 +-
 include/react/detail/IReactiveGraph.h       | 10 +++++-----
 include/react/detail/graph/AlgorithmNodes.h | 10 ++--------
 include/react/detail/graph/PropagationST.h  |  2 ++
 4 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/include/react/API.h b/include/react/API.h
index 435e6562..dbbf88f9 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -44,7 +44,7 @@ enum class WeightHint
 
 enum class TransactionFlags
 {
-    none = 1 << 0,
+    none          = 0,
     allow_merging = 1 << 1
 };
 
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/IReactiveGraph.h
index 4cf87bf0..e081844f 100644
--- a/include/react/detail/IReactiveGraph.h
+++ b/include/react/detail/IReactiveGraph.h
@@ -39,11 +39,11 @@ enum class UpdateResult
 
 enum class NodeFlags
 {
-    none,
-    input,
-    output,
-    dynamic,
-    buffered
+    none     = 0,
+    input    = 1 << 0,
+    output   = 1 << 1,
+    dynamic  = 1 << 2,
+    buffered = 1 << 3
 };
 REACT_DEFINE_BITMASK_OPERATORS(NodeFlags)
 
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 6d696532..b5bb7aa6 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -416,7 +416,7 @@ class MonitorNode : public EventStreamNode<S>
         MonitorNode::EventStreamNode( graphPtr ),
         target_( target )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered);
         this->AttachToMe(target->GetNodeId());
     }
 
@@ -428,10 +428,7 @@ class MonitorNode : public EventStreamNode<S>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turnId, true);
-
         this->Events().push_back(target_->Value());
-
         return UpdateResult::changed;
     }
 
@@ -457,7 +454,7 @@ class PulseNode : public EventStreamNode<S>
         target_( target ),
         trigger_( trigger )
     {
-        this->RegisterMe();
+        this->RegisterMe(NodeFlags::buffered);
         this->AttachToMe(target->GetNodeId());
         this->AttachToMe(trigger->GetNodeId());
     }
@@ -471,9 +468,6 @@ class PulseNode : public EventStreamNode<S>
 
     virtual UpdateResult Update(TurnId turnId) override
     {
-        this->SetCurrentTurn(turn, true);
-        trigger_->SetCurrentTurn(turn);
-
         for (size_t i=0; i<trigger_->Events().size(); i++)
             this->Events().push_back(target_->Value());
 
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index 863df8e5..96d4fee4 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -208,6 +208,8 @@ void SingleThreadedGraph::DoTransaction(TransactionFlags flags, F&& transactionC
     // Propagate changes through the graph.
     if (! scheduledNodes_.IsEmpty())
         Propagate();
+
+    ClearBufferedNodes();
 }
 
 void SingleThreadedGraph::Propagate()

From 5a988398d629623ae6ace185c27974c001fd87a6 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 5 Sep 2016 23:02:30 +0200
Subject: [PATCH 35/75] Progress. SlotNodes.

---
 examples/src/BasicEvents.cpp                |  38 ++-
 examples/src/BasicSignals.cpp               |  36 ++-
 include/react/API.h                         |  20 +-
 include/react/Event.h                       | 115 ++++++++-
 include/react/Group.h                       |  28 ++-
 include/react/Signal.h                      | 133 +++++++++--
 include/react/detail/IReactiveGraph.h       |  50 ++--
 include/react/detail/graph/AlgorithmNodes.h |  94 +++++---
 include/react/detail/graph/EventNodes.h     | 228 ++++++++++++------
 include/react/detail/graph/GraphBase.h      |  16 +-
 include/react/detail/graph/ObserverNodes.h  |  35 +--
 include/react/detail/graph/PropagationST.h  | 251 +++++++++++++++-----
 include/react/detail/graph/SignalNodes.h    | 209 ++++++++++++----
 13 files changed, 941 insertions(+), 312 deletions(-)

diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index b9a7cfbd..0f4f3f06 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -237,12 +237,46 @@ namespace example5
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    example1::v1::Run();
+    using namespace std;
+    using namespace react;
+
+    ReactiveGroup<> group;
+
+    auto ev1 = EventSource<int>( group );
+    auto ev2 = EventSource<int>( group );
+
+    auto slot1 = EventSlot<int>( ev1, group );
+    auto slot2 = EventSlot<int>( ev1, group );
+
+    Observer<> obs1(
+        [] (EventRange<int> in)
+        {
+            for (int e : in)
+                cout << e << endl;
+        }, slot1);
+
+    Observer<> obs2(
+        [] (EventRange<int> in)
+        {
+            for (int e : in)
+                cout << e << endl;
+        }, slot2);
+
+    ev1 << 10 << 20 << 30;
+    ev2 << 11 << 22 << 33;
+
+    slot1.Set(ev2);
+    slot2.Set(ev2);
+
+    ev1 << 10 << 20 << 30;
+    ev2 << 11 << 22 << 33;
+
+    /*example1::v1::Run();
     example1::v2::Run();
     example2::Run();
     example3::Run();
     example4::Run();
-    example5::Run();
+    example5::Run();*/
 
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 3007d199..44369987 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -218,11 +218,43 @@ namespace example5
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    example1::Run();
+    using namespace std;
+    using namespace react;
+
+    ReactiveGroup<> group;
+
+    auto sig1 = VarSignal<int>( 10, group );
+    auto sig2 = VarSignal<int>( 22, group );
+
+    auto slot1 = SignalSlot<int>( sig1, group );
+    auto slot2 = SignalSlot<int>( sig1, group );
+
+    printf("%d\n", slot1.Value());
+    printf("%d\n", slot2.Value());
+
+    slot1.Set(sig2);
+    slot2.Set(sig2);
+
+    printf("%d\n", slot1.Value());
+    printf("%d\n", slot2.Value());
+
+    group.DoTransaction([&]
+    {
+        slot1.Set(sig2);
+        slot2.Set(sig2);
+    });
+
+    group.EnqueueTransaction([&]
+    {
+        slot1.Set(sig2);
+        slot2.Set(sig2);
+    });
+
+    /*example1::Run();
     example2::Run();
     example3::Run();
     example4::Run();
-    example5::Run();
+    example5::Run();*/
 
     return 0;
 }
\ No newline at end of file
diff --git a/include/react/API.h b/include/react/API.h
index dbbf88f9..928d1007 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -59,18 +59,24 @@ template <OwnershipPolicy = unique>
 class ReactiveGroup;
 
 // Signals
-template <typename T>
+template <typename S>
 class SignalBase;
 
-template <typename T>
+template <typename S>
 class VarSignalBase;
 
-template <typename T, OwnershipPolicy = unique>
+template <typename S>
+class SignalSlotBase;
+
+template <typename S, OwnershipPolicy = unique>
 class Signal;
 
-template <typename T, OwnershipPolicy = unique>
+template <typename S, OwnershipPolicy = unique>
 class VarSignal;
 
+template <typename S, OwnershipPolicy = unique>
+class SignalSlot;
+
 // Events
 enum class Token;
 
@@ -80,13 +86,17 @@ class EventBase;
 template <typename E>
 class EventSourceBase;
 
+template <typename E>
+class EventSlotBase;
+
 template <typename E = Token, OwnershipPolicy = unique>
 class Event;
 
 template <typename E = Token, OwnershipPolicy = unique>
 class EventSource;
 
-
+template <typename E, OwnershipPolicy = unique>
+class EventSlot;
 
 // Observers
 template <OwnershipPolicy = unique>
diff --git a/include/react/Event.h b/include/react/Event.h
index 13fdcb5c..2c9222fd 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -100,9 +100,6 @@ class EventBase
 template <typename E = Token>
 class EventSourceBase : public EventBase<E>
 {
-private:
-    using NodeType = REACT_IMPL::EventSourceNode<E>;
-
 public:
     using EventBase::EventBase;
     
@@ -137,7 +134,7 @@ class EventSourceBase : public EventBase<E>
         using REACT_IMPL::PrivateReactiveGroupInterface;
         using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
 
-        return std::make_shared<NodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
+        return std::make_shared<SrcNodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
     }
 
 private:
@@ -145,9 +142,10 @@ class EventSourceBase : public EventBase<E>
     void EmitValue(T&& value)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::IReactiveGraph;
+        using REACT_IMPL::ReactiveGraph;
+        using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
 
-        NodeType* castedPtr = static_cast<NodeType*>(this->NodePtr().get());
+        SrcNodeType* castedPtr = static_cast<SrcNodeType*>(this->NodePtr().get());
 
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = NodePtr()->GraphPtr();
@@ -155,6 +153,55 @@ class EventSourceBase : public EventBase<E>
     }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventSlotBase
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E>
+class EventSlotBase : public EventBase<E>
+{
+public:
+    using EventBase::EventBase;
+
+    void Set(const EventBase<E>& newInput)
+        { SetInput(newInput); }
+
+    void operator<<=(const EventBase<E>& newInput)
+        { SetInput(newInput); }
+
+protected:
+    EventSlotBase() = default;
+
+    EventSlotBase(const EventSlotBase&) = default;
+    EventSlotBase& operator=(const EventSlotBase&) = default;
+
+    EventSlotBase(EventSlotBase&&) = default;
+    EventSlotBase& operator=(EventSlotBase&&) = default;
+
+    auto CreateSlotNode(const EventBase<E>& input, const ReactiveGroupBase& group) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
+
+        return std::make_shared<SlotNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), PrivateNodeInterface::NodePtr(input));
+    }
+
+private:
+    void SetInput(const EventBase<E>& newInput)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        using REACT_IMPL::NodeId;
+        using REACT_IMPL::ReactiveGraph;
+        using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
+
+        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->NodePtr().get());
+
+        NodeId nodeId = castedPtr->GetInputNodeId();
+        auto& graphPtr = NodePtr()->GraphPtr();
+        graphPtr->AddInput(nodeId, [castedPtr, &newInput] { castedPtr->SetInput(PrivateNodeInterface::NodePtr(newInput)); });
+    }
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Event
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -277,6 +324,62 @@ class EventSource<E, shared> : public EventSourceBase<E>
         { EventSource::EventSourceBase::operator=(std::move(other)); return *this; }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventSlot
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E>
+class EventSlot<E, unique> : public EventSlotBase<E>
+{
+public:
+    using EventSlotBase::EventSlotBase;
+
+    using ValueType = E;
+
+    EventSlot() = delete;
+
+    EventSlot(const EventSlot&) = delete;
+    EventSlot& operator=(const EventSlot&) = delete;
+
+    EventSlot(EventSlot&&) = default;
+    EventSlot& operator=(EventSlot&&) = default;
+
+    // Construct with value
+    EventSlot(const EventBase<E>& input, const ReactiveGroupBase& group) :
+        EventSlot::EventSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+        { }
+};
+
+template <typename E>
+class EventSlot<E, shared> : public EventSlotBase<E>
+{
+public:
+    using EventSlotBase::EventSlotBase;
+
+    using ValueType = E;
+
+    EventSlot() = delete;
+
+    EventSlot(const EventSlot&) = default;
+    EventSlot& operator=(const EventSlot&) = default;
+
+    EventSlot(EventSlot&&) = default;
+    EventSlot& operator=(EventSlot&&) = default;
+
+    // Construct from unique
+    EventSlot(EventSlot<E, unique>&& other) :
+        EventSlot::EventSlotBase( std::move(other) )
+        { }
+
+    // Assign from unique
+    EventSlot& operator=(EventSlot<E, unique>&& other)
+        { EventSlot::EventSlotBase::operator=(std::move(other)); return *this; }
+
+    // Construct with value
+    EventSlot(const SignalBase<E>& input, const ReactiveGroupBase& group) :
+        EventSlot::EventSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+        { }
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Group.h b/include/react/Group.h
index c8324d1c..4ab5d2af 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -140,7 +140,7 @@ void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& fu
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 class ReactiveGroupBase
 {
-    using GraphType = REACT_IMPL::SingleThreadedGraph;
+    using GraphType = REACT_IMPL::ReactiveGraph;
 
 public:
     ReactiveGroupBase() :
@@ -157,11 +157,15 @@ class ReactiveGroupBase
 
     template <typename F>
     void DoTransaction(F&& func)
-        { DoTransaction(TransactionFlags::none, std::forward<F>(func)); }
+        { graphPtr_->DoTransaction(std::forward<F>(func)); }
 
     template <typename F>
-    void DoTransaction(TransactionFlags flags, F&& func)
-        { graphPtr_->DoTransaction(flags, std::forward<F>(func)); }
+    void EnqueueTransaction(F&& func)
+        { EnqueueTransaction(TransactionFlags::none, std::forward<F>(func)); }
+
+    template <typename F>
+    void EnqueueTransaction(TransactionFlags flags, F&& func)
+        { graphPtr_->EnqueueTransaction(flags, std::forward<F>(func)); }
 
 protected:
     auto GraphPtr() -> std::shared_ptr<GraphType>&
@@ -229,31 +233,31 @@ struct PrivateNodeInterface
         { return base.NodePtr(); }
 
     template <typename TBase>
-    static auto GraphPtr(const TBase& base) -> const std::shared_ptr<IReactiveGraph>&
+    static auto GraphPtr(const TBase& base) -> const std::shared_ptr<ReactiveGraph>&
         { return base.NodePtr()->GraphPtr(); }
 
     template <typename TBase>
-    static auto GraphPtr(TBase& base) -> std::shared_ptr<IReactiveGraph>&
+    static auto GraphPtr(TBase& base) -> std::shared_ptr<ReactiveGraph>&
         { return base.NodePtr()->GraphPtr(); }
 };
 
 struct PrivateReactiveGroupInterface
 {
-    static auto GraphPtr(const ReactiveGroupBase& group) -> const std::shared_ptr<SingleThreadedGraph>&
+    static auto GraphPtr(const ReactiveGroupBase& group) -> const std::shared_ptr<ReactiveGraph>&
         { return group.GraphPtr(); }
 
-    static auto GraphPtr(ReactiveGroupBase& group) -> std::shared_ptr<SingleThreadedGraph>&
+    static auto GraphPtr(ReactiveGroupBase& group) -> std::shared_ptr<ReactiveGraph>&
         { return group.GraphPtr(); }
 };
 
 template <typename TBase1, typename ... TBases>
-static auto GetCheckedGraphPtr(const TBase1& dep1, const TBases& ... deps) -> const std::shared_ptr<IReactiveGraph>&
+static auto GetCheckedGraphPtr(const TBase1& dep1, const TBases& ... deps) -> const std::shared_ptr<ReactiveGraph>&
 {
-    const std::shared_ptr<IReactiveGraph>& graphPtr1 = PrivateNodeInterface::GraphPtr(dep1);
+    const std::shared_ptr<ReactiveGraph>& graphPtr1 = PrivateNodeInterface::GraphPtr(dep1);
 
-    std::initializer_list<IReactiveGraph*> rawGraphPtrs = { PrivateNodeInterface::GraphPtr(deps).get() ... };
+    std::initializer_list<ReactiveGraph*> rawGraphPtrs = { PrivateNodeInterface::GraphPtr(deps).get() ... };
 
-    bool isSameGraphForAllDeps = std::all_of(rawGraphPtrs.begin(), rawGraphPtrs.end(), [&] (IReactiveGraph* p) { return p == graphPtr1.get(); });
+    bool isSameGraphForAllDeps = std::all_of(rawGraphPtrs.begin(), rawGraphPtrs.end(), [&] (ReactiveGraph* p) { return p == graphPtr1.get(); });
 
     REACT_ASSERT(isSameGraphForAllDeps, "All dependencies must belong to the same group.");
 
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 22e4e548..dab00344 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -112,8 +112,7 @@ class VarSignalBase : public SignalBase<S>
     VarSignalBase(VarSignalBase&&) = default;
     VarSignalBase& operator=(VarSignalBase&&) = default;
 
-    template <typename TGroup>
-    auto CreateVarNode(const TGroup& group) -> decltype(auto)
+    auto CreateVarNode(const ReactiveGroupBase& group) -> decltype(auto)
     {
         using REACT_IMPL::PrivateReactiveGroupInterface;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
@@ -121,8 +120,8 @@ class VarSignalBase : public SignalBase<S>
         return std::make_shared<VarNodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
     }
 
-    template <typename T, typename TGroup>
-    auto CreateVarNode(T&& value, const TGroup& group) -> decltype(auto)
+    template <typename T>
+    auto CreateVarNode(T&& value, const ReactiveGroupBase& group) -> decltype(auto)
     {
         using REACT_IMPL::PrivateReactiveGroupInterface;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
@@ -135,7 +134,7 @@ class VarSignalBase : public SignalBase<S>
     void SetValue(T&& newValue)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::IReactiveGraph;
+        using REACT_IMPL::ReactiveGraph;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
@@ -149,7 +148,7 @@ class VarSignalBase : public SignalBase<S>
     void ModifyValue(const F& func)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::IReactiveGraph;
+        using REACT_IMPL::ReactiveGraph;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
@@ -160,6 +159,55 @@ class VarSignalBase : public SignalBase<S>
     }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SignalSlotBase
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class SignalSlotBase : public SignalBase<S>
+{
+public:
+    using SignalBase::SignalBase;
+
+    void Set(const SignalBase<S>& newInput)
+        { SetInput(newInput); }
+
+    void operator<<=(const SignalBase<S>& newInput)
+        { SetInput(newInput); }
+
+protected:
+    SignalSlotBase() = default;
+
+    SignalSlotBase(const SignalSlotBase&) = default;
+    SignalSlotBase& operator=(const SignalSlotBase&) = default;
+
+    SignalSlotBase(SignalSlotBase&&) = default;
+    SignalSlotBase& operator=(SignalSlotBase&&) = default;
+
+    auto CreateSlotNode(const SignalBase<S>& input, const ReactiveGroupBase& group) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
+
+        return std::make_shared<SlotNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), PrivateNodeInterface::NodePtr(input));
+    }
+
+private:
+    void SetInput(const SignalBase<S>& newInput)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        using REACT_IMPL::NodeId;
+        using REACT_IMPL::ReactiveGraph;
+        using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
+
+        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->NodePtr().get());
+
+        NodeId nodeId = castedPtr->GetInputNodeId();
+        auto& graphPtr = NodePtr()->GraphPtr();
+        graphPtr->AddInput(nodeId, [castedPtr, &newInput] { castedPtr->SetInput(PrivateNodeInterface::NodePtr(newInput)); });
+    }
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -219,7 +267,7 @@ class Signal<S, shared> : public SignalBase<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signal
+/// VarSignal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
 class VarSignal<S, unique> : public VarSignalBase<S>
@@ -273,7 +321,7 @@ class VarSignal<S, shared> : public VarSignalBase<S>
 
     // Assign from unique
     VarSignal& operator=(VarSignal<S, unique>&& other)
-        { VarSignal::SignalBase::operator=(std::move(other)); return *this; }
+        { VarSignal::VarSignalBase::operator=(std::move(other)); return *this; }
 
     // Construct with default
     template <typename TGroup>
@@ -289,15 +337,70 @@ class VarSignal<S, shared> : public VarSignalBase<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten
+/// SignalSlot
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/*template <typename TInner, EOwnershipPolicy ownership_policy>
-auto Flatten(const SignalBase<SignalBase<TInner>>& outer) -> Signal<TInner, ownership_policy>
+template <typename S>
+class SignalSlot<S, unique> : public SignalSlotBase<S>
 {
-    return Signal<TInner>(
-        std::make_shared<REACT_IMPL::FlattenNode<Signal<TInner>, TInner>>(
-            GetNodePtr(outer), GetNodePtr(outer.Value())));
-}*/
+public:
+    using SignalSlotBase::SignalSlotBase;
+
+    using ValueType = S;
+
+    SignalSlot() = delete;
+
+    SignalSlot(const SignalSlot&) = delete;
+    SignalSlot& operator=(const SignalSlot&) = delete;
+
+    SignalSlot(SignalSlot&&) = default;
+    SignalSlot& operator=(SignalSlot&&) = default;
+
+    // Construct with default
+    explicit SignalSlot(const ReactiveGroupBase& group) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode( group) )
+        { }
+
+    // Construct with value
+    SignalSlot(const SignalBase<S>& input, const ReactiveGroupBase& group) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+        { }
+};
+
+template <typename S>
+class SignalSlot<S, shared> : public SignalSlotBase<S>
+{
+public:
+    using SignalSlotBase::SignalSlotBase;
+
+    using ValueType = S;
+
+    SignalSlot() = delete;
+
+    SignalSlot(const SignalSlot&) = default;
+    SignalSlot& operator=(const SignalSlot&) = default;
+
+    SignalSlot(SignalSlot&&) = default;
+    SignalSlot& operator=(SignalSlot&&) = default;
+
+    // Construct from unique
+    SignalSlot(SignalSlot<S, unique>&& other) :
+        SignalSlot::SignalSlotBase( std::move(other) )
+        { }
+
+    // Assign from unique
+    SignalSlot& operator=(SignalSlot<S, unique>&& other)
+        { SignalSlot::SignalSlotBase::operator=(std::move(other)); return *this; }
+
+    // Construct with default
+    explicit SignalSlot(const ReactiveGroupBase& group) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode( group) )
+        { }
+
+    // Construct with value
+    SignalSlot(const SignalBase<S>& input, const ReactiveGroupBase& group) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+        { }
+};
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/IReactiveGraph.h
index e081844f..594f3801 100644
--- a/include/react/detail/IReactiveGraph.h
+++ b/include/react/detail/IReactiveGraph.h
@@ -13,6 +13,7 @@
 
 #include <functional>
 #include <memory>
+#include <unordered_set>
 #include <utility>
 
 #include "react/API.h"
@@ -26,48 +27,28 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 using NodeId = size_t;
 using TurnId = size_t;
+using LinkId = size_t;
 
 static NodeId invalid_node_id = (std::numeric_limits<size_t>::max)();
 static TurnId invalid_turn_id = (std::numeric_limits<size_t>::max)();
+static LinkId invalid_link_id = (std::numeric_limits<size_t>::max)();
 
 enum class UpdateResult
 {
     unchanged,
-    changed,
-    shifted
+    changed
 };
 
-enum class NodeFlags
+enum class NodeCategory
 {
-    none     = 0,
-    input    = 1 << 0,
-    output   = 1 << 1,
-    dynamic  = 1 << 2,
-    buffered = 1 << 3
+    normal,
+    input,
+    dyninput,
+    output,
+    link
 };
-REACT_DEFINE_BITMASK_OPERATORS(NodeFlags)
 
-struct IReactiveGraph;
-struct IReactiveNode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IReactiveGraph
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IReactiveGraph
-{
-    virtual ~IReactiveGraph() = default;
-
-    virtual NodeId RegisterNode(IReactiveNode* nodePtr, NodeFlags flags) = 0;
-    virtual void UnregisterNode(NodeId node) = 0;
-
-    virtual void OnNodeAttach(NodeId nodeId, NodeId parentId) = 0;
-    virtual void OnNodeDetach(NodeId nodeId, NodeId parentId) = 0;
-
-    virtual void OnDynamicNodeAttach(NodeId nodeId, NodeId parentId, TurnId turn) = 0;
-    virtual void OnDynamicNodeDetach(NodeId nodeId, NodeId parentId, TurnId turn) = 0;
-
-    virtual void AddInput(NodeId nodeId, std::function<void()> inputCallback) = 0;
-};
+class ReactiveGraph;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IReactiveNode
@@ -78,11 +59,16 @@ struct IReactiveNode
 
     virtual const char* GetNodeType() const = 0;
 
-    virtual UpdateResult Update(TurnId turnId) = 0;  
+    virtual UpdateResult Update(TurnId turnId, int successorCount) = 0;
 
     virtual int GetDependencyCount() const = 0;
+};
+
+using LinkOutputList = std::vector<std::pair<ReactiveGraph*, IReactiveNode*>>;
 
-    virtual void ClearBuffer() = 0;
+struct ILinkOutputNode : public IReactiveNode
+{
+    virtual void CollectOutput(LinkOutputList& output) = 0;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index b5bb7aa6..62ff5c9a 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -86,7 +86,7 @@ class IterateNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    IterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
+    IterateNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
         IterateNode::SignalNode( graphPtr, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events )
@@ -101,10 +101,12 @@ class IterateNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         S newValue = func_(EventRange<E>( events_->Events() ), this->Value());
 
+        events_->DecrementPendingSuccessorCount();
+
         if (! (newValue == this->Value()))
         {
             this->Value() = std::move(newValue);
@@ -136,7 +138,7 @@ class IterateByRefNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    IterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
+    IterateByRefNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
         IterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events )
@@ -151,10 +153,12 @@ class IterateByRefNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         func_(EventRange<E>( events_->Events() ), this->Value());
 
+        events_->DecrementPendingSuccessorCount();
+
         // Always assume change
         return UpdateResult::changed;
     }
@@ -179,7 +183,7 @@ class SyncedIterateNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+    SyncedIterateNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
         SyncedIterateNode::SignalNode( graphPtr, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events ),
@@ -197,8 +201,12 @@ class SyncedIterateNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
+        // Updates might be triggered even if only sync nodes changed. Ignore those.
+        if (events_->Events().empty())
+            return UpdateResult::unchanged;
+
         S newValue = apply(
             [this] (const auto& ... syncs)
             {
@@ -206,6 +214,8 @@ class SyncedIterateNode : public SignalNode<S>
             },
             syncHolder_);
 
+        events_->DecrementPendingSuccessorCount();
+
         if (! (newValue == this->Value()))
         {
             this->Value() = std::move(newValue);
@@ -239,7 +249,7 @@ class SyncedIterateByRefNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateByRefNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+    SyncedIterateByRefNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
         SyncedIterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events ),
@@ -257,27 +267,23 @@ class SyncedIterateByRefNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        events_->SetCurrentTurn(turnId);
+        // Updates might be triggered even if only sync nodes changed. Ignore those.
+        if (events_->Events().empty())
+            return UpdateResult::unchanged;
 
-        bool changed = false;
+        apply(
+            [this] (const auto& ... args)
+            {
+                func_(EventRange<E>( events_->Events() ), this->Value(), args->Value() ...);
+            },
+            syncHolder_);
 
-        if (! events_->Events().empty())
-        {
-            apply(
-                [this] (const auto& ... args)
-                {
-                    func_(EventRange<E>( events_->Events() ), this->Value(), args->Value() ...);
-                },
-                syncHolder_);
+        events_->DecrementPendingSuccessorCount();
+        this->SetPendingSuccessorCount(successorCount);
 
-            return UpdateResult::changed;
-        }
-        else
-        {
-            return UpdateResult::unchanged;
-        }
+        return UpdateResult::changed;
     }
 
     virtual const char* GetNodeType() const override
@@ -302,7 +308,7 @@ class HoldNode : public SignalNode<S>
 {
 public:
     template <typename T>
-    HoldNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& init, const std::shared_ptr<EventStreamNode<S>>& events) :
+    HoldNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, const std::shared_ptr<EventStreamNode<S>>& events) :
         HoldNode::SignalNode( graphPtr, std::forward<T>(init) ),
         events_( events )
     {
@@ -319,7 +325,7 @@ class HoldNode : public SignalNode<S>
     virtual const char* GetNodeType() const override
         { return "HoldNode"; }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         bool changed = false;
 
@@ -332,6 +338,8 @@ class HoldNode : public SignalNode<S>
                 changed = true;
                 this->Value() = newValue;
             }
+
+            events_->DecrementPendingSuccessorCount();
         }
 
         if (changed)
@@ -354,7 +362,7 @@ template <typename S, typename E>
 class SnapshotNode : public SignalNode<S>
 {
 public:
-    SnapshotNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
+    SnapshotNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
         SnapshotNode::SignalNode( graphPtr, target->Value() ),
         target_( target ),
         trigger_( trigger )
@@ -371,21 +379,21 @@ class SnapshotNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        trigger_->SetCurrentTurn(turnId);
-
         bool changed = false;
         
         if (! trigger_->Events().empty())
         {
             const S& newValue = target_->Value();
 
-            if (! Equals(newValue, this->Value()))
+            if (! (newValue == this->Value()))
             {
                 changed = true;
                 this->Value() = newValue;
             }
+
+            trigger_->DecrementPendingSuccessorCount();
         }
 
         if (changed)
@@ -412,11 +420,11 @@ template <typename S>
 class MonitorNode : public EventStreamNode<S>
 {
 public:
-    MonitorNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target) :
+    MonitorNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target) :
         MonitorNode::EventStreamNode( graphPtr ),
         target_( target )
     {
-        this->RegisterMe(NodeFlags::buffered);
+        this->RegisterMe();
         this->AttachToMe(target->GetNodeId());
     }
 
@@ -426,9 +434,12 @@ class MonitorNode : public EventStreamNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         this->Events().push_back(target_->Value());
+
+        this->SetPendingSuccessorCount(successorCount);
+
         return UpdateResult::changed;
     }
 
@@ -449,12 +460,12 @@ template <typename S, typename E>
 class PulseNode : public EventStreamNode<S>
 {
 public:
-    PulseNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
+    PulseNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
         PulseNode::EventStreamNode( graphPtr ),
         target_( target ),
         trigger_( trigger )
     {
-        this->RegisterMe(NodeFlags::buffered);
+        this->RegisterMe();
         this->AttachToMe(target->GetNodeId());
         this->AttachToMe(trigger->GetNodeId());
     }
@@ -466,19 +477,26 @@ class PulseNode : public EventStreamNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         for (size_t i=0; i<trigger_->Events().size(); i++)
             this->Events().push_back(target_->Value());
 
+        trigger_->DecrementPendingSuccessorCount();
+
         if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
+        }
         else
+        {
             return UpdateResult::unchanged;
+        }
     }
 
     virtual const char* GetNodeType() const override
-        { return "PulseNode"; }
+        { return "Pulse"; }
 
     virtual int GetDependencyCount() const override
         { return 2; }
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index caf2e049..6a457a98 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -27,19 +27,19 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterators for event processing
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T = Token>
+template <typename E = Token>
 class EventRange
 {
 public:
-    using const_iterator = typename std::vector<T>::const_iterator;
-    using size_type = typename std::vector<T>::size_type;
+    using const_iterator = typename std::vector<E>::const_iterator;
+    using size_type = typename std::vector<E>::size_type;
 
     EventRange() = delete;
 
     EventRange(const EventRange&) = default;
     EventRange& operator=(const EventRange&) = default;
 
-    explicit EventRange(const std::vector<T>& data) :
+    explicit EventRange(const std::vector<E>& data) :
         data_( data )
         { }
 
@@ -56,11 +56,11 @@ class EventRange
         { return data_.empty(); }
 
 private:
-    const std::vector<T>&    data_;
+    const std::vector<E>&    data_;
 };
 
-template <typename T>
-using EventSink = std::back_insert_iterator<std::vector<T>>;
+template <typename E>
+using EventSink = std::back_insert_iterator<std::vector<E>>;
 
 /******************************************/ REACT_END /******************************************/
 
@@ -69,17 +69,17 @@ using EventSink = std::back_insert_iterator<std::vector<T>>;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
+template <typename S>
 class SignalNode;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventStreamNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
+template <typename E>
 class EventStreamNode : public NodeBase
 {
 public:
-    using StorageType = std::vector<T>;
+    using StorageType = std::vector<E>;
 
     EventStreamNode(EventStreamNode&&) = default;
     EventStreamNode& operator=(EventStreamNode&&) = default;
@@ -87,7 +87,7 @@ class EventStreamNode : public NodeBase
     EventStreamNode(const EventStreamNode&) = delete;
     EventStreamNode& operator=(const EventStreamNode&) = delete;
 
-    explicit EventStreamNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+    explicit EventStreamNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
         NodeBase( graphPtr )
         { }
 
@@ -97,11 +97,37 @@ class EventStreamNode : public NodeBase
     const StorageType& Events() const
         { return events_; }
 
-    virtual void ClearBuffer() override
-        { events_.clear(); };
+
+    void SetPendingSuccessorCount(int count)
+    {
+        if (count == 0)
+        {
+            // If there are no successors, buffer is cleared immediately.
+            events_.clear();
+        }
+        else
+        {
+            // Otherwise, the last finished successor clears it.
+            pendingSuccessorCount_ = count;
+        }
+    }
+
+    void DecrementPendingSuccessorCount()
+    {
+        // Not all predecessors of a node might be visited during a turn.
+        // In this case, the count is zero and the call to this function should be ignored.
+        if (pendingSuccessorCount_ == 0)
+            return;
+
+        // Last successor to arrive clears the buffer.
+        if (pendingSuccessorCount_-- == 1)
+            events_.clear();
+    };
 
 private:
     StorageType events_;
+    
+    std::atomic<int> pendingSuccessorCount_ = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -111,9 +137,9 @@ template <typename T>
 class EventSourceNode : public EventStreamNode<T>
 {
 public:
-    EventSourceNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+    EventSourceNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
         EventSourceNode::EventStreamNode( graphPtr )
-        { this->RegisterMe(NodeFlags::buffered | NodeFlags::input); }
+        { this->RegisterMe(NodeCategory::input); }
 
     ~EventSourceNode()
         { this->UnregisterMe(); }
@@ -124,10 +150,11 @@ class EventSourceNode : public EventStreamNode<T>
     virtual int GetDependencyCount() const override
         { return 0; }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        if (this->Events().size() > 0)
-        {            
+        if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
         }
         else
@@ -138,9 +165,7 @@ class EventSourceNode : public EventStreamNode<T>
 
     template <typename U>
     void EmitValue(U&& value)
-    {
-        this->Events().push_back(std::forward<U>(value));
-    }
+        { this->Events().push_back(std::forward<U>(value)); }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -150,11 +175,11 @@ template <typename TOut, typename ... TIns>
 class EventMergeNode : public EventStreamNode<TOut>
 {
 public:
-    EventMergeNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIns>>& ... deps) :
+    EventMergeNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIns>>& ... deps) :
         EventMergeNode::EventStreamNode( graphPtr ),
         depHolder_( deps ... )
     {
-        this->RegisterMe(NodeFlags::buffered);
+        this->RegisterMe();
         REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
@@ -164,14 +189,19 @@ class EventMergeNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
         if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
+        }
         else
+        {
             return UpdateResult::unchanged;
+        }
     }
 
     virtual const char* GetNodeType() const override
@@ -185,70 +215,108 @@ class EventMergeNode : public EventStreamNode<TOut>
     void MergeFromDep(const std::shared_ptr<EventStreamNode<U>>& other)
     {
         this->Events().insert(this->Events().end(), other->Events().begin(), other->Events().end());
+        other->DecrementPendingSuccessorCount();
     }
 
     std::tuple<std::shared_ptr<EventStreamNode<TIns>> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventFlattenNode
+/// EventSlotNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TOuter, typename TInner>
-class EventFlattenNode : public EventStreamNode<TInner>
+template <typename E>
+class EventSlotNode : public EventStreamNode<E>
 {
 public:
-    EventFlattenNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<TOuter>>& outer, const std::shared_ptr<EventStreamNode<TInner>>& inner) :
-        EventFlattenNode::EventStreamNode( graphPtr ),
-        outer_( outer ),
-        inner_( inner )
+    EventSlotNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<E>>& dep) :
+        EventSlotNode::EventStreamNode( graphPtr ),
+        slotInput_( *this, dep )
     {
-        this->RegisterMe(NodeFlags::buffered | NodeFlags::dynamic);
-        this->AttachToMe(outer->GetNodeId());
-        this->AttachToMe(inner->GetNodeId());
+        slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
+        this->RegisterMe();
+
+        this->AttachToMe(slotInput_.nodeId);
+        this->AttachToMe(dep->GetNodeId());
     }
 
-    ~EventFlattenNode()
+    ~EventSlotNode()
     {
-        this->DetachFromMe(inner->GetNodeId());
-        this->DetachFromMe(outer->GetNodeId());
+        this->DetachFromMe(slotInput_.dep->GetNodeId());
+        this->DetachFromMe(slotInput_.nodeId);
+
         this->UnregisterMe();
+        GraphPtr()->UnregisterNode(slotInput_.nodeId);
     }
 
     virtual const char* GetNodeType() const override
-        { return "EventFlatten"; }
+        { return "EventSlot"; }
 
     virtual int GetDependencyCount() const override
         { return 2; }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        auto newInner = GetNodePtr(outer_->Value());
+        this->Events().insert(this->Events().end(), slotInput_.dep->Events().begin(), slotInput_.dep->Events().end());
 
-        if (newInner != inner_)
+        slotInput_.dep->DecrementPendingSuccessorCount();
+
+        if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
+            return UpdateResult::changed;
+        }
+        else
         {
-            newInner->SetCurrentTurn(turnId);
+            return UpdateResult::unchanged;
+        }
+    }
+
+    void SetInput(const std::shared_ptr<EventStreamNode<E>>& newInput)
+        { slotInput_.newDep = newInput; }
+
+    NodeId GetInputNodeId() const
+        { return slotInput_.nodeId; }
 
-            // Topology has been changed
-            auto oldInner = inner_;
-            inner_ = newInner;
+private:        
+    struct VirtualInputNode : public IReactiveNode
+    {
+        VirtualInputNode(EventSlotNode& parentIn, const std::shared_ptr<EventStreamNode<E>>& depIn) :
+            parent( parentIn ),
+            dep( depIn )
+            { }
 
-            this->DynamicDetachFromMe(oldInner->GetNodeId(), 0);
-            this->DynamicAttachToMe(newInner->GetNodeId(), 0);
+        virtual const char* GetNodeType() const override
+            { return "EventSlotVirtualInput"; }
+
+        virtual int GetDependencyCount() const override
+            { return 0; }
+
+        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        {
+            if (dep != newDep)
+            {
+                parent.DynamicDetachFromMe(dep->GetNodeId(), 0);
+                parent.DynamicAttachToMe(newDep->GetNodeId(), 0);
 
-            return UpdateResult::shifted;
+                dep = std::move(newDep);
+                return UpdateResult::changed;
+            }
+            else
+            {
+                newDep.reset();
+                return UpdateResult::unchanged;
+            }
         }
 
-        this->Events().insert(this->Events().end(), inner_->Events().begin(), inner_->Events().end());
+        EventSlotNode& parent;
 
-        if (! this->Events().empty())
-            return UpdateResult::changed;
-        else
-            return UpdateResult::unchanged;
-    }
+        NodeId nodeId;
 
-private:
-    std::shared_ptr<SignalNode<TOuter>>       outer_;
-    std::shared_ptr<EventStreamNode<TInner>>  inner_;
+        std::shared_ptr<EventStreamNode<E>> dep;
+        std::shared_ptr<EventStreamNode<E>> newDep;
+    };
+
+    VirtualInputNode slotInput_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -259,12 +327,12 @@ class EventProcessingNode : public EventStreamNode<TOut>
 {
 public:
     template <typename FIn>
-    EventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep) :
+    EventProcessingNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep) :
         EventProcessingNode::EventStreamNode( graphPtr ),
         func_( std::forward<FIn>(func) ),
         dep_( dep )
     {
-        this->RegisterMe(NodeFlags::buffered);
+        this->RegisterMe();
         this->AttachToMe(dep->GetNodeId());
     }
 
@@ -274,14 +342,21 @@ class EventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         func_(EventRange<TIn>( dep_->Events() ), std::back_inserter(this->Events()));
 
+        dep_->DecrementPendingSuccessorCount();
+
         if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
+        }
         else
+        {
             return UpdateResult::unchanged;
+        }
     }
 
     virtual const char* GetNodeType() const override
@@ -304,13 +379,13 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 {
 public:
     template <typename FIn>
-    SyncedEventProcessingNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+    SyncedEventProcessingNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
         SyncedEventProcessingNode::EventStreamNode( graphPtr ),
         func_( std::forward<FIn>(func) ),
         dep_( dep ),
         syncHolder_( syncs ... )
     {
-        this->RegisterMe(NodeFlags::buffered);
+        this->RegisterMe();
         this->AttachToMe(dep->GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
@@ -322,7 +397,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (dep_->Events().empty())
@@ -335,14 +410,21 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
             },
             syncHolder_);
 
+        dep_->DecrementPendingSuccessorCount();
+
         if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
+        }
         else
+        {
             return UpdateResult::unchanged;
+        }
     }
 
     virtual const char* GetNodeType() const override
-        { return "SycnedEventProcessing"; }
+        { return "SyncedEventProcessing"; }
 
     virtual int GetDependencyCount() const override
         { return 1 + sizeof...(TSyncs); }
@@ -350,7 +432,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<TIn>>   dep_;
+    std::shared_ptr<EventStreamNode<TIn>> dep_;
 
     std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
@@ -362,11 +444,11 @@ template <typename ... Ts>
 class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 {
 public:
-    EventJoinNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<Ts>>& ... deps) :
+    EventJoinNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<Ts>>& ... deps) :
         EventJoinNode::EventStreamNode( graphPtr ),
         slots_( deps ... )
     {
-        this->RegisterMe(NodeFlags::buffered);
+        this->RegisterMe();
         REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
@@ -376,9 +458,9 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        // Move events into buffers
+        // Move events into buffers.
         apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
 
         while (true)
@@ -396,7 +478,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
             if (!isReady)
                 break;
 
-            // Pop values from buffers and emit tuple
+            // Pop values from buffers and emit tuple.
             apply(
                 [this] (Slot<Ts>& ... slots)
                 {
@@ -407,9 +489,14 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         }
 
         if (! this->Events().empty())
+        {
+            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
+        }
         else
+        {
             return UpdateResult::unchanged;
+        }
     }
 
     virtual const char* GetNodeType() const override
@@ -434,6 +521,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     static void FetchBuffer(TurnId turnId, Slot<U>& slot)
     {
         slot.buffer.insert(slot.buffer.end(), slot.source->Events().begin(), slot.source->Events().end());
+        slot.source->DecrementPendingSuccessorCount();
     }
 
     template <typename T>
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 8466d77b..d39809bb 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -21,7 +21,7 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-struct IReactiveGraph;
+class ReactiveGraph;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// NodeBase
@@ -29,7 +29,7 @@ struct IReactiveGraph;
 class NodeBase : public IReactiveNode
 {
 public:
-    NodeBase(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+    NodeBase(const std::shared_ptr<ReactiveGraph>& graphPtr) :
         graphPtr_( graphPtr )
         { }
     
@@ -58,15 +58,15 @@ class NodeBase : public IReactiveNode
     NodeId GetNodeId() const
         { return nodeId_; }
 
-    auto GraphPtr() const -> const std::shared_ptr<IReactiveGraph>&
+    auto GraphPtr() const -> const std::shared_ptr<ReactiveGraph>&
         { return graphPtr_; }
 
-    auto GraphPtr() -> std::shared_ptr<IReactiveGraph>&
+    auto GraphPtr() -> std::shared_ptr<ReactiveGraph>&
         { return graphPtr_; }
 
 protected:
-    void RegisterMe(NodeFlags flags = NodeFlags::none)
-        { nodeId_ = graphPtr_->RegisterNode(this, flags); }
+    void RegisterMe(NodeCategory category = NodeCategory::normal)
+        { nodeId_ = graphPtr_->RegisterNode(this, category); }
     
     void UnregisterMe()
         { graphPtr_->UnregisterNode(nodeId_); }
@@ -84,9 +84,9 @@ class NodeBase : public IReactiveNode
         { graphPtr_->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
 
 private:
-    NodeId          nodeId_;
+    NodeId nodeId_;
 
-    std::shared_ptr<IReactiveGraph> graphPtr_;
+    std::shared_ptr<ReactiveGraph> graphPtr_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index abdf1c6e..f8887d8b 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -35,12 +35,9 @@ class EventStreamNode;
 class ObserverNode : public NodeBase
 {
 public:
-    ObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+    ObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
         ObserverNode::NodeBase( graphPtr )
         { }
-
-    virtual void ClearBuffer() override
-        { };
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -51,12 +48,12 @@ class SignalObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SignalObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
+    SignalObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
         SignalObserverNode::ObserverNode( graphPtr ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
-        this->RegisterMe(NodeFlags::output);
+        this->RegisterMe(NodeCategory::output);
         REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
     }
 
@@ -72,7 +69,7 @@ class SignalObserverNode : public ObserverNode
     virtual int GetDependencyCount() const override
         { return sizeof...(TDeps); }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         apply([this] (const auto& ... deps) { this->func_(deps->Value() ...); }, depHolder_);
         return UpdateResult::unchanged;
@@ -92,12 +89,12 @@ class EventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    EventObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject) :
+    EventObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject) :
         EventObserverNode::ObserverNode( graphPtr ),
         func_( std::forward<FIn>(func) ),
         subject_( subject )
     {
-        this->RegisterMe(NodeFlags::output);
+        this->RegisterMe(NodeCategory::output);
         this->AttachToMe(subject->GetNodeId());
     }
 
@@ -113,9 +110,10 @@ class EventObserverNode : public ObserverNode
     virtual int GetDependencyCount() const override
         { return 1; }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         func_(EventRange<E>( subject_->Events() ));
+        subject_->DecrementPendingSuccessorCount();
         return UpdateResult::unchanged;
     }
 
@@ -133,13 +131,13 @@ class SyncedEventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SyncedEventObserverNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
+    SyncedEventObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
         SyncedEventObserverNode::ObserverNode( graphPtr ),
         func_( std::forward<FIn>(func) ),
         subject_( subject ),
         syncHolder_( syncs ... )
     {
-        this->RegisterMe(NodeFlags::output);
+        this->RegisterMe(NodeCategory::output);
         this->AttachToMe(subject->GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
     }
@@ -157,13 +155,16 @@ class SyncedEventObserverNode : public ObserverNode
     virtual int GetDependencyCount() const override
         { return 1 + sizeof...(TSyncs); }
 
-    virtual UpdateResult Update(TurnId turnId) override
-    {   
-        // Update of this node could be triggered from deps,
-        // so make sure source doesnt contain events from last turn
-        subject_->SetCurrentTurn(turnId);
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    {
+        // Updates might be triggered even if only sync nodes changed. Ignore those.
+        if (events_->Events().empty())
+            return UpdateResult::unchanged;
 
         apply([this] (const auto& ... syncs) { func_(EventRange<E>( this->subject_->Events() ), syncs->Value() ...); }, syncHolder_);
+
+        subject_->DecrementPendingSuccessorCount();
+
         return UpdateResult::unchanged;
     }
 
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index 96d4fee4..e0eb2f59 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -12,34 +12,100 @@
 #include "react/detail/Defs.h"
 
 #include <algorithm>
+#include <atomic>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
+#include <tbb/concurrent_queue.h>
+#include <tbb/task.h>
+
 #include "react/common/Containers.h"
 #include "react/common/Types.h"
 #include "react/detail/IReactiveGraph.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-class SingleThreadedGraph : public IReactiveGraph
+class ReactiveGraph;
+
+class TransactionQueue
+{
+public:
+    TransactionQueue(ReactiveGraph& graph) :
+        graph_( graph )
+        { }
+
+    TransactionQueue(const TransactionQueue&) = delete;
+    TransactionQueue& operator=(const TransactionQueue&) = delete;
+
+    TransactionQueue(TransactionQueue&&) = default;
+    TransactionQueue& operator =(TransactionQueue&&) = default;
+
+    template <typename F>
+    void Push(TransactionFlags flags, F&& transaction)
+    {
+        if (count_.fetch_add(1, std::memory_order_relaxed) == 0)
+            tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(*this));
+    }
+
+private:
+    struct StoredTransaction
+    {
+        TransactionFlags        flags;
+        std::function<void()>   callback;
+    };
+
+    class WorkerTask : public tbb::task
+    {
+    public:
+        WorkerTask(TransactionQueue& parent) :
+            parent_( parent )
+            { }
+
+        tbb::task* execute()
+        {
+            parent_.ProcessQueue();
+            return nullptr;
+        }
+
+    private:
+        TransactionQueue& parent_;
+    };
+
+    void ProcessQueue();
+
+    size_t ProcessNextBatch();
+
+    tbb::concurrent_queue<StoredTransaction> transactions_;
+
+    std::atomic<size_t> count_{ 0 };
+
+    ReactiveGraph& graph_;
+};
+
+class ReactiveGraph
 {
 public:
-    // IReactiveGraph
-    virtual NodeId RegisterNode(IReactiveNode* nodePtr, NodeFlags flags) override;
-    virtual void UnregisterNode(NodeId node) override;
+    NodeId RegisterNode(IReactiveNode* nodePtr, NodeCategory category);
+    void UnregisterNode(NodeId nodeId);
 
-    virtual void OnNodeAttach(NodeId node, NodeId parentId) override;
-    virtual void OnNodeDetach(NodeId node, NodeId parentId) override;
+    void OnNodeAttach(NodeId node, NodeId parentId);
+    void OnNodeDetach(NodeId node, NodeId parentId);
 
-    virtual void OnDynamicNodeAttach(NodeId node, NodeId parentId, TurnId turnId) override;
-    virtual void OnDynamicNodeDetach(NodeId node, NodeId parentId, TurnId turnId) override;
+    void OnDynamicNodeAttach(NodeId node, NodeId parentId, TurnId turnId);
+    void OnDynamicNodeDetach(NodeId node, NodeId parentId, TurnId turnId);
 
-    virtual void AddInput(NodeId nodeId, std::function<void()> inputCallback) override;
-    // ~IReactiveGraph
+    LinkId AddGroupLink(ILinkNodeOutput* nodePtr, NodeCategory category);
+    void RemoveGroupLink(LinkId nodeId);
 
     template <typename F>
-    void DoTransaction(TransactionFlags flags, F&& transactionCallback);
+    void AddInput(NodeId nodeId, F&& inputCallback);
+
+    template <typename F>
+    void DoTransaction(F&& transactionCallback);
+
+    template <typename F>
+    void EnqueueTransaction(TransactionFlags flags, F&& transactionCallback);
 
 private:
     struct NodeData
@@ -49,12 +115,12 @@ class SingleThreadedGraph : public IReactiveGraph
         NodeData(const NodeData&) = default;
         NodeData& operator=(const NodeData&) = default;
 
-        NodeData(IReactiveNode* nodePtrIn, NodeFlags flagsIn) :
+        NodeData(IReactiveNode* nodePtrIn, NodeCategory categoryIn) :
             nodePtr( nodePtrIn ),
-            flags( flagsIn )
+            category(categoryIn)
         { }
 
-        NodeFlags flags = NodeFlags::none;
+        NodeCategory category = NodeCategory::normal;
 
         int     level       = 0;
         int     newLevel    = 0 ;
@@ -90,35 +156,34 @@ class SingleThreadedGraph : public IReactiveGraph
     };
 
     void Propagate();
+    void UpdateLinkNodes();
 
     void ScheduleSuccessors(NodeData & node);
     void InvalidateSuccessors(NodeData & node);
-    void ClearBufferedNodes();
 
 private:
-    int refCount_ = 1;
+    TransactionQueue    transactionQueue_{ *this };
 
     TopoQueue           scheduledNodes_;
     IndexMap<NodeData>  nodeData_;
     std::vector<NodeId> changedInputs_;
-
-    std::vector<IReactiveNode*> pendingBufferedNodes_;
+    std::vector<NodeId> scheduledLinkNodes_;
 
     bool isTransactionActive_ = false;
 };
 
-NodeId SingleThreadedGraph::RegisterNode(IReactiveNode* nodePtr, NodeFlags flags)
+NodeId ReactiveGraph::RegisterNode(IReactiveNode* nodePtr, NodeCategory category)
 {
-    return nodeData_.Insert(NodeData{ nodePtr, flags });
+    return nodeData_.Insert(NodeData{ nodePtr, category });
 }
 
-void SingleThreadedGraph::UnregisterNode(NodeId nodeId)
+void ReactiveGraph::UnregisterNode(NodeId nodeId)
 {
     nodeData_.Remove(nodeId);
 
 }
 
-void SingleThreadedGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
+void ReactiveGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
 {
     auto& node = nodeData_[nodeId];
     auto& parent = nodeData_[parentId];
@@ -129,7 +194,7 @@ void SingleThreadedGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
         node.level = parent.level + 1;
 }
 
-void SingleThreadedGraph::OnNodeDetach(NodeId nodeId, NodeId parentId)
+void ReactiveGraph::OnNodeDetach(NodeId nodeId, NodeId parentId)
 {
     auto& parent = nodeData_[parentId];
     auto& successors = parent.successors;
@@ -137,17 +202,18 @@ void SingleThreadedGraph::OnNodeDetach(NodeId nodeId, NodeId parentId)
     successors.erase(std::find(successors.begin(), successors.end(), nodeId));
 }
 
-void SingleThreadedGraph::OnDynamicNodeAttach(NodeId nodeId, NodeId parentId, TurnId turnId)
+void ReactiveGraph::OnDynamicNodeAttach(NodeId nodeId, NodeId parentId, TurnId turnId)
 {
     OnNodeAttach(nodeId, parentId);
 }
 
-void SingleThreadedGraph::OnDynamicNodeDetach(NodeId nodeId, NodeId parentId, TurnId turnId)
+void ReactiveGraph::OnDynamicNodeDetach(NodeId nodeId, NodeId parentId, TurnId turnId)
 {
     OnNodeDetach(nodeId, parentId);
 }
 
-void SingleThreadedGraph::AddInput(NodeId nodeId, std::function<void()> inputCallback)
+template <typename F>
+void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
 {
     auto& node = nodeData_[nodeId];
     auto* nodePtr = node.nodePtr;
@@ -163,25 +229,22 @@ void SingleThreadedGraph::AddInput(NodeId nodeId, std::function<void()> inputCal
     }
     else
     {
+        int successorCount = node.successors.size();
+
         // Update the node. This applies the input buffer to the node value and checks if it changed.
-        if (nodePtr->Update(0) == UpdateResult::changed)
+        if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
         {
-            if (IsBitmaskSet(node.flags, NodeFlags::buffered))
-                pendingBufferedNodes_.push_back(nodePtr);
-
             // Propagate changes through the graph
             ScheduleSuccessors(node);
 
             if (! scheduledNodes_.IsEmpty())
                 Propagate();
         }
-
-        ClearBufferedNodes();
     }
 }
 
 template <typename F>
-void SingleThreadedGraph::DoTransaction(TransactionFlags flags, F&& transactionCallback)
+void ReactiveGraph::DoTransaction(F&& transactionCallback)
 {
     // Transaction callback may add multiple inputs.
     isTransactionActive_ = true;
@@ -194,10 +257,12 @@ void SingleThreadedGraph::DoTransaction(TransactionFlags flags, F&& transactionC
         auto& node = nodeData_[nodeId];
         auto* nodePtr = node.nodePtr;
 
-        if (nodePtr->Update(0) == UpdateResult::changed)
+        int successorCount = node.successors.size();
+
+        if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
         {
-            if (IsBitmaskSet(node.flags, NodeFlags::buffered))
-                pendingBufferedNodes_.push_back(nodePtr);
+            if (node.category == NodeCategory::dyninput)
+                InvalidateSuccessors(node);
 
             ScheduleSuccessors(node);
         }
@@ -209,10 +274,17 @@ void SingleThreadedGraph::DoTransaction(TransactionFlags flags, F&& transactionC
     if (! scheduledNodes_.IsEmpty())
         Propagate();
 
-    ClearBufferedNodes();
+    if (!scheduledLinkNodes_.empty())
+        UpdateLinkNodes();
 }
 
-void SingleThreadedGraph::Propagate()
+template <typename F>
+void ReactiveGraph::EnqueueTransaction(TransactionFlags flags, F&& transactionCallback)
+{
+    transactionQueue_.Push(flags, std::forward<F>(transactionCallback));
+}
+
+void ReactiveGraph::Propagate()
 {
     while (scheduledNodes_.FetchNext())
     {
@@ -230,29 +302,27 @@ void SingleThreadedGraph::Propagate()
                 continue;
             }
 
-            auto result = nodePtr->Update(0);
+            int successorCount = node.successors.size();
 
-            if (result == UpdateResult::changed)
+            if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
             {
-                if (IsBitmaskSet(node.flags, NodeFlags::buffered))
-                    pendingBufferedNodes_.push_back(nodePtr);
-
                 ScheduleSuccessors(node);
             }
-            else if (result == UpdateResult::shifted)
-            {
-                // Re-schedule this node
-                InvalidateSuccessors(node);
-                scheduledNodes_.Push(nodeId, node.level);
-                continue;
-            }
 
             node.queued = false;
         }
     }
 }
 
-void SingleThreadedGraph::ScheduleSuccessors(NodeData& node)
+void ReactiveGraph::UpdateLinkNodes()
+{
+    for (const auto& x : scheduledLinkNodes_)
+    {
+
+    }
+}
+
+void ReactiveGraph::ScheduleSuccessors(NodeData& node)
 {
     for (NodeId succId : node.successors)
     {
@@ -261,12 +331,16 @@ void SingleThreadedGraph::ScheduleSuccessors(NodeData& node)
         if (!succ.queued)
         {
             succ.queued = true;
-            scheduledNodes_.Push(succId, succ.level);
+
+            if (node.category != NodeCategory::link)
+                scheduledNodes_.Push(succId, succ.level);
+            else
+                scheduledLinkNodes_.push_back(succId);
         }
     }
 }
 
-void SingleThreadedGraph::InvalidateSuccessors(NodeData& node)
+void ReactiveGraph::InvalidateSuccessors(NodeData& node)
 {
     for (NodeId succId : node.successors)
     {
@@ -277,14 +351,7 @@ void SingleThreadedGraph::InvalidateSuccessors(NodeData& node)
     }
 }
 
-void SingleThreadedGraph::ClearBufferedNodes()
-{
-    for (IReactiveNode* nodePtr : pendingBufferedNodes_)
-        nodePtr->ClearBuffer();
-    pendingBufferedNodes_.clear();
-}
-
-bool SingleThreadedGraph::TopoQueue::FetchNext()
+bool ReactiveGraph::TopoQueue::FetchNext()
 {
     // Throw away previous values
     nextData_.clear();
@@ -310,6 +377,68 @@ bool SingleThreadedGraph::TopoQueue::FetchNext()
     return !nextData_.empty();
 }
 
+void TransactionQueue::ProcessQueue()
+{
+    for (;;)
+    {
+        size_t popCount = ProcessNextBatch();
+        if (count_.fetch_sub(popCount) == popCount)
+            return;
+    }
+}
+
+size_t TransactionQueue::ProcessNextBatch()
+{
+    StoredTransaction curTransaction;
+    size_t popCount = 0;
+    bool canMerge = false;
+    bool skipPop = false;
+    bool isDone = false;
+
+    // Outer loop. One transaction per iteration.
+    for (;;)
+    {
+        if (!skipPop)
+        {
+            if (transactions_.try_pop(curTransaction))
+                return popCount;
+
+            canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
+            ++popCount;
+        }
+        else
+        {
+            skipPop = false;
+        }
+
+        graph_.DoTransaction([&]
+        {
+            curTransaction.callback();
+
+            if (canMerge)
+            {
+                // Inner loop. Mergeable transactions are merged
+                for (;;)
+                {
+                    if (transactions_.try_pop(curTransaction))
+                        return;
+
+                    canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
+                    ++popCount;
+
+                    if (!canMerge)
+                    {
+                        skipPop = true;
+                        return;
+                    }
+
+                    curTransaction.callback();
+                }
+            }
+        });
+    }
+}
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 30128a3e..2bdd3eac 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -12,7 +12,9 @@
 #include "react/detail/Defs.h"
 
 #include <memory>
+#include <queue>
 #include <utility>
+#include <vector>
 
 #include "GraphBase.h"
 
@@ -37,13 +39,13 @@ class SignalNode : public NodeBase
     SignalNode(const SignalNode&) = delete;
     SignalNode& operator=(const SignalNode&) = delete;
 
-    explicit SignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+    explicit SignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
         SignalNode::NodeBase( graphPtr ),
         value_( )
         { }
 
     template <typename T>
-    SignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& value) :
+    SignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& value) :
         SignalNode::NodeBase( graphPtr ),
         value_( std::forward<T>(value) )
         { }
@@ -54,9 +56,6 @@ class SignalNode : public NodeBase
     const S& Value() const
         { return value_; }
 
-    virtual void ClearBuffer() override
-        { };
-
 private:
     S value_;
 };
@@ -68,13 +67,13 @@ template <typename S>
 class VarSignalNode : public SignalNode<S>
 {
 public:
-    explicit VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr) :
+    explicit VarSignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
         VarSignalNode::SignalNode( graphPtr ),
         newValue_( )
-        { this->RegisterMe(NodeFlags::input); }
+        { this->RegisterMe(NodeCategory::input); }
 
     template <typename T>
-    VarSignalNode(const std::shared_ptr<IReactiveGraph>& graphPtr, T&& value) :
+    VarSignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& value) :
         VarSignalNode::SignalNode( graphPtr, std::forward<T>(value) ),
         newValue_( value )
         { this->RegisterMe(); }
@@ -88,7 +87,7 @@ class VarSignalNode : public SignalNode<S>
     virtual int GetDependencyCount() const override
         { return 0; }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         if (isInputAdded_)
         {
@@ -162,7 +161,7 @@ class SignalFuncNode : public SignalNode<S>
 {
 public:
     template <typename FIn>
-    SignalFuncNode(const std::shared_ptr<IReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
+    SignalFuncNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
         SignalFuncNode::SignalNode( graphPtr, func(deps->Value() ...) ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
@@ -183,7 +182,7 @@ class SignalFuncNode : public SignalNode<S>
     virtual int GetDependencyCount() const override
         { return sizeof...(TDeps); }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {   
         bool changed = false;
 
@@ -208,54 +207,43 @@ class SignalFuncNode : public SignalNode<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// FlattenNode
+/// SignalSlotNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TOuter, typename TInner>
-class SignalFlattenNode : public SignalNode<TInner>
+template <typename S>
+class SignalSlotNode : public SignalNode<S>
 {
 public:
-    SignalFlattenNode(const std::shared_ptr<IReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<TOuter>>& outer, const std::shared_ptr<SignalNode<TInner>>& inner) :
-        SignalFlattenNode::SignalNode( graphPtr, inner->Value() ),
-        outer_( outer ),
-        inner_( inner )
+    SignalSlotNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& dep) :
+        SignalSlotNode::SignalNode( graphPtr, dep->Value() ),
+        slotInput_( *this, dep )
     {
-        this->RegisterMe(NodeFlags::dynamic);
-        this->AttachToMe(outer->GetNodeId());
-        this->AttachToMe(inner->GetNodeId());
+        slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
+        this->RegisterMe();
+
+        this->AttachToMe(slotInput_.nodeId);
+        this->AttachToMe(dep->GetNodeId());
     }
 
-    ~SignalFlattenNode()
+    ~SignalSlotNode()
     {
-        this->DetachFromMe(inner->GetNodeId());
-        this->DetachFromMe(outer->GetNodeId());
+        this->DetachFromMe(slotInput_.dep->GetNodeId());
+        this->DetachFromMe(slotInput_.nodeId);
+
         this->UnregisterMe();
+        GraphPtr()->UnregisterNode(slotInput_.nodeId);
     }
 
     virtual const char* GetNodeType() const override
-        { return "SignalFlatten"; }
+        { return "SignalSlot"; }
 
     virtual int GetDependencyCount() const override
         { return 2; }
 
-    virtual UpdateResult Update(TurnId turnId) override
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        auto newInner = GetNodePtr(outer_->Value());
-
-        if (newInner != inner_)
+        if (! (this->Value() == slotInput_.dep->Value()))
         {
-            // Topology has been changed
-            auto oldInner = inner_;
-            inner_ = newInner;
-
-            this->DynamicDetachFromMe(oldInner->GetNodeId(), 0);
-            this->DynamicAttachToMe(newInner->GetNodeId(), 0);
-
-            return UpdateResult::shifted;
-        }
-
-        if (! Equals(this->Value(), inner_->Value()))
-        {
-            this->Value() = inner_->Value();
+            this->Value() = slotInput_.dep->Value();
             return UpdateResult::changed;
         }
         else
@@ -264,9 +252,142 @@ class SignalFlattenNode : public SignalNode<TInner>
         }
     }
 
+    void SetInput(const std::shared_ptr<SignalNode<S>>& newInput)
+        { slotInput_.newDep = newInput; }
+
+    NodeId GetInputNodeId() const
+        { return slotInput_.nodeId; }
+
+private:        
+    struct VirtualInputNode : public IReactiveNode
+    {
+        VirtualInputNode(SignalSlotNode& parentIn, const std::shared_ptr<SignalNode<S>>& depIn) :
+            parent( parentIn ),
+            dep( depIn )
+            { }
+
+        virtual const char* GetNodeType() const override
+            { return "SignalSlotVirtualInput"; }
+
+        virtual int GetDependencyCount() const override
+            { return 0; }
+
+        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        {
+            if (dep != newDep)
+            {
+                parent.DynamicDetachFromMe(dep->GetNodeId(), 0);
+                parent.DynamicAttachToMe(newDep->GetNodeId(), 0);
+
+                dep = std::move(newDep);
+                return UpdateResult::changed;
+            }
+            else
+            {
+                newDep.reset();
+                return UpdateResult::unchanged;
+            }
+        }
+
+        SignalSlotNode& parent;
+
+        NodeId nodeId;
+
+        std::shared_ptr<SignalNode<S>> dep;
+        std::shared_ptr<SignalNode<S>> newDep;
+    };
+
+    VirtualInputNode slotInput_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SignalBridgeNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class SignalLinkNode : public SignalNode<S>
+{
+public:
+    SignalLinkNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<ReactiveGraph>& srcGraphPtr, const std::shared_ptr<SignalNode<S>>& dep) :
+        SignalLinkNode::SignalNode( graphPtr, dep->Value() ),
+        linkOutput_( *this, srcGraphPtr, dep )
+    {
+        slotInput_.nodeId = GraphPtr()->RegisterNode(&linkOutput_, NodeCategory::dyninput);
+        this->RegisterMe();
+
+        this->AttachToMe(slotInput_.nodeId);
+        this->AttachToMe(dep->GetNodeId());
+    }
+
+    ~SignalLinkNode()
+    {
+        this->DetachFromMe(slotInput_.dep->GetNodeId());
+        this->DetachFromMe(slotInput_.nodeId);
+
+        this->UnregisterMe();
+        GraphPtr()->UnregisterNode(slotInput_.nodeId);
+    }
+
+    virtual const char* GetNodeType() const override
+        { return "SignalLink"; }
+
+    virtual int GetDependencyCount() const override
+        { return 2; }
+
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    {
+        {// outputDataMutex
+            std::lock_guard lock(linkOutput_.outputDataMutex);
+            this->Value() = std::move(linkOutput_.outputData.front());
+            linkOutput_.outputData.pop();
+        }// ~outputDataMutex
+
+        return UpdateResult::changed;
+    }
+
 private:
-    std::shared_ptr<SignalNode<TOuter>> outer_;
-    std::shared_ptr<SignalNode<TInner>> inner_;
+    struct VirtualOutputNode : public ILinkOutputNode
+    {
+        VirtualOutputNode(SignalSlotNode& parentIn, const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<SignalNode<S>>& depIn) :
+            parent( parentIn ),
+            srcGraphPtr(srcGraphPtrIn),
+            dep( depIn )
+            { }
+
+        virtual const char* GetNodeType() const override
+            { return "SignalLinkVirtualOutput"; }
+
+        virtual int GetDependencyCount() const override
+            { return 1; }
+
+        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        {
+            {// outputDataMutex
+                std::lock_guard lock(outputDataMutex);
+                outputData.push(dep->Value());
+            }// ~outputDataMutex
+            
+            return UpdateResult::changed;
+        }
+
+        virtual void CollectOutput(LinkOutputList& output) override
+            { output.emplace_back(srcGraphPtr.get(), &parent); }
+
+        SignalSlotNode& parent;
+
+        NodeId nodeId;
+
+        std::shared_ptr<SignalNode<S>> dep;
+
+        std::mutex outputDataMutex;
+
+        std::queue<S, std::vector<S>> outputData;
+
+        std::shared_ptr<ReactiveGraph> srcGraphPtr;
+    };
+
+    VirtualOutputNode linkOutput_;
+
+    
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/

From a7ae030ef76f7c2de5bba1ec5d1014671c69500c Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 9 Dec 2016 18:13:31 +0100
Subject: [PATCH 36/75] Progress...

---
 examples/src/Main.cpp                      | 245 ++++++++++++++++++--
 include/react/API.h                        |  12 +-
 include/react/Event.h                      | 221 +++++++++++++++---
 include/react/Group.h                      |   2 +-
 include/react/Observer.h                   |  89 ++++++--
 include/react/Signal.h                     | 246 +++++++++++++++++----
 include/react/detail/IReactiveGraph.h      |   8 +-
 include/react/detail/graph/EventNodes.h    | 101 ++++++++-
 include/react/detail/graph/PropagationST.h |  63 ++++--
 include/react/detail/graph/SignalNodes.h   |  90 ++++----
 10 files changed, 888 insertions(+), 189 deletions(-)

diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 89f61f07..62d5c079 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -4,37 +4,248 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-//#define REACT_ENABLE_LOGGING
+#include <cstdio>
+#include <vector>
+#include <chrono>
+#include <thread>
 
-#include "react/Domain.h"
 #include "react/Signal.h"
 #include "react/Event.h"
 #include "react/Algorithm.h"
+#include "react/Observer.h"
 
-#include "tbb/tick_count.h"
+using namespace react;
 
-#include <chrono>
+template <typename T>
+T Multiply(T a, T b)
+{
+	return a * b;
+}
 
-using namespace std;
-using namespace react;
+template <typename T> void PrintValue(T v)
+{
+	printf("Value: %d\n", v);
+}
+
+template <typename T> void PrintArea(T v)
+{
+	printf("Area: %d\n", v);
+}
+
+template <typename T> void PrintVolume(T v)
+{
+	printf("Volume: %d\n", v);
+}
 
-void testme()
+template <typename T> void PrintEvents(EventRange<T> evts)
 {
-    // Note: This project exists as a sandbox where I occasionally stage new examples.
-    // Currently it's empty.
+	printf("Processing events...\n");
+
+	for (const auto& e : evts)
+		printf("  Event: %d\n", e);
+}
+
+template <typename T> bool FilterFunc(T v)
+{
+	return v > 10;
+}
+
+int main2()
+{
+	ReactiveGroup<> group;
+
+	{
+		// Signals
+		VarSignal<int> x{ group, 0 };
+		VarSignal<int> y{ group, 0 };
+		VarSignal<int> z{ group, 0 };
+
+		Signal<int> area{ Multiply<int>, x, y };
+		Signal<int> volume{ Multiply<int>, area, z };
+
+		Observer<> areaObs{ PrintArea<int>, area };
+		Observer<> volumeObs{ PrintVolume<int>, volume };
+
+		x.Set(2); // a: 0, v: 0
+		y.Set(2); // a: 4, v: 0
+		z.Set(2); // a: 4, v: 8
+
+		group.DoTransaction([&]
+		{
+			x <<= 100;
+			y <<= 3;
+			y <<= 4;
+		});
+
+		// a: 400, v: 800
+	}
+
+	{
+		// Events
+		EventSource<int> button1{ group };
+		EventSource<int> button2{ group };
+
+		Event<int> anyButton = Merge(button1, button2);
+		Event<int> filtered  = Filter(FilterFunc<int>, anyButton);
+
+		Observer<> eventObs{ PrintEvents<int>, anyButton };
+
+		button1.Emit(1);
+		button2.Emit(2);
+
+		group.DoTransaction([&]
+		{
+			for (int i=0; i<10; ++i)
+				button1.Emit(42);
+		});
+	}
+
+	{
+		// Dynamic signals
+		VarSignal<int> s1{ group, 10 };
+		VarSignal<int> s2{ group, 22 };
+
+		SignalSlot<int> slot{ s1 };
+
+		Observer<> areaObs{ PrintValue<int>, slot };
+
+		s1.Set(42);
+
+		slot.Set(s2);
+
+		s2.Set(667);
+	}
+
+	{
+		ReactiveGroup<> group1;
+		ReactiveGroup<> group2;
+
+		VarSignal<int> s1{ group1, 10 };
+		VarSignal<int> s2{ group2, 11 };
+
+		Signal<int> v{ Multiply<int>, s1, s2 };
+
+		Observer<> obs{ PrintValue<int>, v };
+
+		s1.Set(555);
+
+		std::this_thread::sleep_for(std::chrono::seconds(5));
+	}
+
+	{
+		ReactiveGroup<> group1;
+		ReactiveGroup<> group2;
+
+		EventSource<int> e1{ group1 };
+		EventSource<int> e2{ group2 };
+
+		auto merged = Merge(group2, e1, e2);
+
+		auto joined = Join(e1, e2);
+		auto joined2 = Join(group1, e1, e2);
+
+		Observer<> eventObs{ PrintEvents<int>, merged };
+
+		e1.Emit(222);
+
+		std::this_thread::sleep_for(std::chrono::seconds(5));
+	}
+
+	return 0;
 }
 
 int main()
 {
-    testme();
+	ReactiveGroup<> group;
+
+	VarSignal<int> a{  };
+	VarSignal<int> b{  };
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*int main2()
+{
+	ReactiveGroup<> group1;
+	ReactiveGroup<> group2;
+	ReactiveGroup<> group3;
+
+	VarSignal<int> x{ 0, group1 };
+	VarSignal<int> y{ 0, group2 };
+	VarSignal<int> z{ 0, group3 };
+
+	Signal<int> area{ Multiply<int>, x, y };
+	Signal<int> volume{ Multiply<int>, area, z };
+
+	Observer<> obs{ PrintAreaAndVolume, area, volume };
+
+	Signal<vector<int>> volumeHistory = Iterate<vector<int>>( vector<int>{ }, PushToVector, Monitor(volume));
+
+	x <<= 2;
+	y <<= 2;
+	z <<= 2;
+
+	group.DoTransaction([&]
+	{
+		x <<= 100;
+		y <<= 200;
+		z <<= 300;
+	});
+
+	obs.Cancel();
+
+	x <<= 42;
+
+	printf("History:\n");
+	for (auto t : volumeHistory.Value())
+		printf("%d ", t);
+	printf("\n");
+
+	return 0;
+}
+
+
+int main3()
+{
+    using namespace std;
+    using namespace react;
+
+    ReactiveGroup<> group1;
+		ReactiveGroup<> group2;
+
+    auto sig1 = VarSignal<int>( 10, group1 );
 
-#ifdef REACT_ENABLE_LOGGING
-    std::ofstream logfile;
-    logfile.open("log.txt");
+    auto link1 = SignalLink<int>( sig1, group2 );
+		auto link2 = SignalLink<int>( sig1, group2 );
 
-    D::Log().Write(logfile);
-    logfile.close();
-#endif
+		sig1.Set(10);
 
     return 0;
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/include/react/API.h b/include/react/API.h
index 928d1007..79a44241 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -29,12 +29,6 @@ enum ReferencePolicy
     weak
 };
 
-enum ThreadingPolicy
-{
-    sequential,
-    concurrent
-};
-
 enum class WeightHint
 {
     automatic,
@@ -68,6 +62,9 @@ class VarSignalBase;
 template <typename S>
 class SignalSlotBase;
 
+template <typename S>
+class SignalLinkBase;
+
 template <typename S, OwnershipPolicy = unique>
 class Signal;
 
@@ -77,6 +74,9 @@ class VarSignal;
 template <typename S, OwnershipPolicy = unique>
 class SignalSlot;
 
+template <typename S, OwnershipPolicy = unique>
+class SignalLink;
+
 // Events
 enum class Token;
 
diff --git a/include/react/Event.h b/include/react/Event.h
index 2c9222fd..89bcc0c8 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -19,6 +19,12 @@
 
 #include "react/detail/graph/EventNodes.h"
 
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+struct PrivateEventLinkNodeInterface;
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -32,7 +38,7 @@ class EventBase
 
 public:
     // Private node ctor
-    EventBase(REACT_IMPL::NodeCtorTag, std::shared_ptr<NodeType>&& nodePtr) :
+    EventBase(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
         { }
 
@@ -128,13 +134,10 @@ class EventSourceBase : public EventBase<E>
     EventSourceBase(EventSourceBase&& other) = default;
     EventSourceBase& operator=(EventSourceBase&& other) = default;
 
-    template <typename TGroup>
-    auto CreateSourceNode(const TGroup& group) -> decltype(auto)
+    auto CreateSourceNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateReactiveGroupInterface;
         using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
-
-        return std::make_shared<SrcNodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
+        return std::make_shared<SrcNodeType>(graphPtr);
     }
 
 private:
@@ -177,7 +180,7 @@ class EventSlotBase : public EventBase<E>
     EventSlotBase(EventSlotBase&&) = default;
     EventSlotBase& operator=(EventSlotBase&&) = default;
 
-    auto CreateSlotNode(const EventBase<E>& input, const ReactiveGroupBase& group) -> decltype(auto)
+    auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const EventBase<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::PrivateReactiveGroupInterface;
@@ -202,6 +205,38 @@ class EventSlotBase : public EventBase<E>
     }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventLinkBase
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E>
+class EventLinkBase : public EventBase<E>
+{
+public:
+    using EventBase::EventBase;
+
+protected:
+    EventLinkBase() = default;
+
+    EventLinkBase(const EventLinkBase&) = default;
+    EventLinkBase& operator=(const EventLinkBase&) = default;
+
+    EventLinkBase(EventLinkBase&&) = default;
+    EventLinkBase& operator=(EventLinkBase&&) = default;
+
+    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const EventBase<E>& input) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using EventNodeType = REACT_IMPL::EventLinkNode<E>;
+
+        auto node = std::make_shared<EventNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
+				node->SetWeakSelfPtr(std::weak_ptr<EventNodeType>{ node });
+				return node;
+    }
+
+		friend struct REACT_IMPL::PrivateEventLinkNodeInterface;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Event
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -223,12 +258,22 @@ class Event<E, unique> : public EventBase<E>
 
     template <typename F, typename T>
     Event(F&& func, const EventBase<T>& dep) :
-        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
+        { }
+
+    template <typename F, typename T>
+    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep) :
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T, typename ... Us>
     Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        { }
+
+    template <typename F, typename T, typename ... Us>
+    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
         { }
 };
 
@@ -257,12 +302,22 @@ class Event<E, shared> : public EventBase<E>
 
     template <typename F, typename T>
     Event(F&& func, const EventBase<T>& dep) :
-        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
+        { }
+
+    template <typename F, typename T>
+    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep) :
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T, typename ... Us>
     Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( REACT_IMPL::NodeCtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        { }
+
+		template <typename F, typename T, typename ... Us>
+    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
+        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
         { }
 };
 
@@ -286,9 +341,8 @@ class EventSource<E, unique> : public EventSourceBase<E>
     EventSource& operator=(EventSource&&) = default;
 
     // Construct event source
-    template <typename TGroup>
-    explicit EventSource(const TGroup& group) :
-        EventSource::EventSourceBase( REACT_IMPL::NodeCtorTag{ }, CreateSourceNode(group) )
+    explicit EventSource(const ReactiveGroupBase& group) :
+        EventSource::EventSourceBase( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 };
 
@@ -309,9 +363,8 @@ class EventSource<E, shared> : public EventSourceBase<E>
     EventSource& operator=(EventSource&&) = default;
 
     // Construct event source
-    template <typename TGroup>
-    explicit EventSource(const TGroup& group) :
-        EventSource::EventSourceBase( REACT_IMPL::NodeCtorTag{ }, CreateSourceNode(group) )
+    explicit EventSource(const ReactiveGroupBase& group) :
+        EventSource::EventSourceBase( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 
     // Construct from unique
@@ -344,8 +397,8 @@ class EventSlot<E, unique> : public EventSlotBase<E>
     EventSlot& operator=(EventSlot&&) = default;
 
     // Construct with value
-    EventSlot(const EventBase<E>& input, const ReactiveGroupBase& group) :
-        EventSlot::EventSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+    EventSlot(const ReactiveGroupBase& group, const EventBase<E>& input) :
+        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 };
 
@@ -375,21 +428,43 @@ class EventSlot<E, shared> : public EventSlotBase<E>
         { EventSlot::EventSlotBase::operator=(std::move(other)); return *this; }
 
     // Construct with value
-    EventSlot(const SignalBase<E>& input, const ReactiveGroupBase& group) :
-        EventSlot::EventSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+    EventSlot(const ReactiveGroupBase& group, const SignalBase<E>& input) :
+        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T = void, typename U1, typename ... Us>
+auto Merge(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype(auto)
+{
+    using REACT_IMPL::EventMergeNode;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
+
+    // If supplied, use merge type, otherwise default to common type.
+    using E = typename std::conditional<
+        std::is_same<T, void>::value,
+        typename std::common_type<U1, Us ...>::type,
+        T>::type;
+
+		const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Event<E, unique>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
+}
+
 template <typename T = void, typename U1, typename ... Us>
 auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype(auto)
 {
     using REACT_IMPL::EventMergeNode;
-    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+    using REACT_IMPL::CtorTag;
 
     static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
 
@@ -399,15 +474,24 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
         typename std::common_type<U1, Us ...>::type,
         T>::type;
 
-    const auto& graphPtr = GetCheckedGraphPtr(dep1, deps ...);
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
-    return Event<E, unique>( NodeCtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...));
+    return Event<E, unique>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename F, typename E>
+auto Filter(const ReactiveGroupBase& group, F&& pred, const EventBase<E>& dep) -> Event<E, unique>
+{
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
+        { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
+
+    return Event<E, unique>(group, std::move(filterFunc), dep);
+}
+
 template <typename F, typename E>
 auto Filter(F&& pred, const EventBase<E>& dep) -> Event<E, unique>
 {
@@ -417,6 +501,19 @@ auto Filter(F&& pred, const EventBase<E>& dep) -> Event<E, unique>
     return Event<E, unique>(std::move(filterFunc), dep);
 }
 
+template <typename F, typename E, typename ... Ts>
+auto Filter(const ReactiveGroupBase& group, F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals) -> Event<E, unique>
+{
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
+    {
+        for (const auto& v : inRange)
+            if (capturedPred(v, values ...))
+                *out++ = v;
+    };
+
+    return Event<E, unique>(group, std::move(filterFunc), dep, signals ...);
+}
+
 template <typename F, typename E, typename ... Ts>
 auto Filter(F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals) -> Event<E, unique>
 {
@@ -433,6 +530,15 @@ auto Filter(F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Transform
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E, typename F, typename T>
+auto Transform(const ReactiveGroupBase& group, F&& op, const EventBase<T>& dep) -> Event<E, unique>
+{
+    auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
+        { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
+
+    return Event<E, unique>(group, std::move(transformFunc), dep);
+}
+
 template <typename E, typename F, typename T>
 auto Transform(F&& op, const EventBase<T>& dep) -> Event<E, unique>
 {
@@ -442,6 +548,18 @@ auto Transform(F&& op, const EventBase<T>& dep) -> Event<E, unique>
     return Event<E, unique>(std::move(transformFunc), dep);
 }
 
+template <typename E, typename F, typename T, typename ... Us>
+auto Transform(const ReactiveGroupBase& group, F&& op, const EventBase<T>& dep, const SignalBase<Us>& ... signals) -> Event<E, unique>
+{
+    auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
+    {
+        for (const auto& v : inRange)
+            *out++ = capturedPred(v, values ...);
+    };
+
+    return Event<E, unique>(group, std::move(transformFunc), dep, signals ...);
+}
+
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(F&& op, const EventBase<T>& dep, const SignalBase<Us>& ... signals) -> Event<E, unique>
 {
@@ -468,21 +586,38 @@ auto Flatten(const Signal<Events<TInnerValue>>& outer) -> Events<TInnerValue>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename ... Ts>
-auto Join(const EventBase<Ts>& ... deps) -> Event<std::tuple<Ts ...>, unique>
+template <typename U1, typename ... Us>
+auto Join(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> Event<std::tuple<U1, Us ...>, unique>
+{
+    using REACT_IMPL::EventJoinNode;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+		using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::CtorTag;
+
+    static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
+
+    // If supplied, use merge type, otherwise default to common type.
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Event<std::tuple<U1, Us ...>, unique>( CtorTag{ }, std::make_shared<EventJoinNode<U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
+}
+
+template <typename U1, typename ... Us>
+auto Join(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> Event<std::tuple<U1, Us ...>, unique>
 {
     using REACT_IMPL::EventJoinNode;
-    using REACT_IMPL::GetCheckedGraphPtr;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+		using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::CtorTag;
 
-    static_assert(sizeof...(Ts) > 1, "Join requires at least 2 inputs.");
+    static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
 
     // If supplied, use merge type, otherwise default to common type.
-    const auto& graphPtr = GetCheckedGraphPtr(deps ...);
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
-    return Event<std::tuple<Ts ...>, unique>( NodeCtorTag{ }, std::make_shared<EventJoinNode<Ts ...>>(
-        graphPtr, PrivateNodeInterface::NodePtr(deps) ...));
+    return Event<std::tuple<U1, Us ...>, unique>( CtorTag{ }, std::make_shared<EventJoinNode<U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -512,6 +647,24 @@ bool Equals(const EventBase<L>& lhs, const EventBase<R>& rhs)
     return lhs.Equals(rhs);
 }
 
+struct PrivateEventLinkNodeInterface
+{
+	template <typename E>
+	static auto GetLocalEventNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const EventBase<E>& dep) -> std::shared_ptr<EventStreamNode<E>>
+	{
+		const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(dep);
+
+		if (sourceGraph == targetGraph)
+		{
+			return PrivateNodeInterface::NodePtr(dep);
+		}
+		else
+		{
+			return EventLinkBase<E>::CreateLinkNode(targetGraph, dep);
+		}
+	}
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_EVENT_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Group.h b/include/react/Group.h
index 4ab5d2af..ac5c1b91 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -23,7 +23,7 @@
 
 struct PrivateReactiveGroupInterface;
 struct PrivateConcurrentReactiveGroupInterface;
-struct NodeCtorTag { };
+struct CtorTag { };
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 9d5c6409..590c5baa 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -56,38 +56,51 @@ class ObserverBase
         { return nodePtr_; }
 
     template <typename F, typename T1, typename ... Ts>
-    auto CreateSignalObserverNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
+    auto CreateSignalObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::GetCheckedGraphPtr;
-        using REACT_IMPL::PrivateNodeInterface;
+				using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<ObsNodeType>(
-            GetCheckedGraphPtr(dep1, deps ...),
+            graphPtr,
             std::forward<F>(func),
-            PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...);
+            PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, deps) ...);
     }
 
-    template <typename F, typename T>
-    auto CreateEventObserverNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
+    template <typename F, typename T1, typename ... Ts>
+    auto CreateSignalObserverNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
+        return CreateSignalObserverNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
+    }
+
+    template <typename F, typename T>
+    auto CreateEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const EventBase<T>& dep) -> decltype(auto)
+    {
+				using REACT_IMPL::PrivateEventLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::EventObserverNode<typename std::decay<F>::type, T>;
 
-        return std::make_shared<ObsNodeType>(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), PrivateNodeInterface::NodePtr(dep));
+        return std::make_shared<ObsNodeType>(graphPtr, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep));
+    }
+
+    template <typename F, typename T>
+    auto CreateEventObserverNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        return CreateSignalObserverNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
     }
 
     template <typename F, typename T, typename ... Us>
     auto CreateSyncedEventObserverNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
     {
-        using REACT_IMPL::GetCheckedGraphPtr;
         using REACT_IMPL::PrivateNodeInterface;
+				using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>;
 
+				const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep);
+
         return std::make_shared<ObsNodeType>(
-            GetCheckedGraphPtr(dep, syncs ...),
-            std::forward<F>(func),
-            PrivateNodeInterface::NodePtr(dep), PrivateNodeInterface::NodePtr(syncs) ...);
+            graphPtr, std::forward<F>(func), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, dep), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, syncs) ...);
     }
 
 private:
@@ -113,23 +126,41 @@ class Observer<unique> : public ObserverBase
     Observer(Observer&&) = default;
     Observer& operator=(Observer&&) = default;
 
-    // Construct signal observer
+    // Construct signal observer with implicit group
     template <typename F, typename ... Ts>
     Observer(F&& func, const SignalBase<Ts>& ... subjects) :
         Observer::ObserverBase( CreateSignalObserverNode(std::forward<F>(func), subjects ...) )
         { }
 
-    // Construct event observer
+    // Construct signal observer with explicit group
+    template <typename F, typename ... Ts>
+    Observer(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... subjects) :
+        Observer::ObserverBase( CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...) )
+        { }
+
+    // Construct event observer with implicit group
     template <typename F, typename T>
     Observer(F&& func, const EventBase<T>& subject) :
-        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject ) )
+        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject) )
         { }
 
-    // Constructed synced event observer
+    // Construct event observer with explicit group
+    template <typename F, typename T>
+    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject) :
+        Observer::ObserverBase( CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject) )
+        { }
+
+    // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
     Observer(F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
         Observer::ObserverBase( CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...) )
         { }
+
+    // Constructed synced event observer with explicit group
+    template <typename F, typename T, typename ... Us>
+    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
+        Observer::ObserverBase( CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...) )
+        { }
 };
 
 template <>
@@ -155,23 +186,41 @@ class Observer<shared> : public ObserverBase
     Observer& operator=(Observer<unique>&& other)
         { Observer::ObserverBase::operator=(std::move(other)); return *this; }
 
-    // Construct signal observer
+    // Construct signal observer with implicit group
     template <typename F, typename ... Ts>
     Observer(F&& func, const SignalBase<Ts>& ... subjects) :
         Observer::ObserverBase( CreateSignalObserverNode(std::forward<F>(func), subjects ...) )
         { }
 
-    // Construct event observer
+    // Construct signal observer with explicit group
+    template <typename F, typename ... Ts>
+    Observer(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... subjects) :
+        Observer::ObserverBase( CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...) )
+        { }
+
+    // Construct event observer with implicit group
     template <typename F, typename T>
     Observer(F&& func, const EventBase<T>& subject) :
-        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject ) )
+        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject) )
         { }
 
-    // Constructed synced event observer
+    // Construct event observer with explicit group
+    template <typename F, typename T>
+    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject) :
+        Observer::ObserverBase( CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject) )
+        { }
+
+    // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
     Observer(F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
         Observer::ObserverBase( CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...) )
         { }
+
+    // Constructed synced event observer with explicit group
+    template <typename F, typename T, typename ... Us>
+    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
+        Observer::ObserverBase( CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...) )
+        { }
 };
 
 /******************************************/ REACT_END /******************************************/
diff --git a/include/react/Signal.h b/include/react/Signal.h
index dab00344..4f733f47 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -24,6 +24,12 @@
 
 #include "react/detail/graph/SignalNodes.h"
 
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+struct PrivateSignalLinkNodeInterface;
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -37,7 +43,7 @@ class SignalBase
 
 public:
     // Private node ctor
-    SignalBase(REACT_IMPL::NodeCtorTag, std::shared_ptr<NodeType>&& nodePtr) :
+    SignalBase(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
         { }
 
@@ -60,16 +66,22 @@ class SignalBase
         { return nodePtr_; }
 
     template <typename F, typename T1, typename ... Ts>
-    auto CreateFuncNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
+    auto CreateFuncNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::GetCheckedGraphPtr;
-        using REACT_IMPL::PrivateNodeInterface;
+				using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using FuncNodeType = REACT_IMPL::SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<FuncNodeType>(
-            GetCheckedGraphPtr(dep1, deps ...),
+            graphPtr,
             std::forward<F>(func),
-            PrivateNodeInterface::NodePtr(dep1), PrivateNodeInterface::NodePtr(deps) ...);
+            PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, deps) ...);
+    }
+
+    template <typename F, typename T1, typename ... Ts>
+    auto CreateFuncNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
+    {
+			using REACT_IMPL::PrivateNodeInterface;
+			return CreateFuncNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
     }
 
 private:
@@ -78,6 +90,7 @@ class SignalBase
     friend struct REACT_IMPL::PrivateNodeInterface;
 };
 
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarSignalBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -112,21 +125,17 @@ class VarSignalBase : public SignalBase<S>
     VarSignalBase(VarSignalBase&&) = default;
     VarSignalBase& operator=(VarSignalBase&&) = default;
 
-    auto CreateVarNode(const ReactiveGroupBase& group) -> decltype(auto)
+    static auto CreateVarNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateReactiveGroupInterface;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
-
-        return std::make_shared<VarNodeType>(PrivateReactiveGroupInterface::GraphPtr(group));
+        return std::make_shared<VarNodeType>(graphPtr);
     }
 
     template <typename T>
-    auto CreateVarNode(T&& value, const ReactiveGroupBase& group) -> decltype(auto)
+    static auto CreateVarNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, T&& value) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateReactiveGroupInterface;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
-
-        return std::make_shared<VarNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value));
+        return std::make_shared<VarNodeType>(graphPtr, std::forward<T>(value));
     }
 
 private:
@@ -183,13 +192,12 @@ class SignalSlotBase : public SignalBase<S>
     SignalSlotBase(SignalSlotBase&&) = default;
     SignalSlotBase& operator=(SignalSlotBase&&) = default;
 
-    auto CreateSlotNode(const SignalBase<S>& input, const ReactiveGroupBase& group) -> decltype(auto)
+    static auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const SignalBase<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateReactiveGroupInterface;
         using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
 
-        return std::make_shared<SlotNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), PrivateNodeInterface::NodePtr(input));
+        return std::make_shared<SlotNodeType>(graphPtr, PrivateNodeInterface::NodePtr(input));
     }
 
 private:
@@ -197,7 +205,6 @@ class SignalSlotBase : public SignalBase<S>
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::ReactiveGraph;
         using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
 
         SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->NodePtr().get());
@@ -208,6 +215,38 @@ class SignalSlotBase : public SignalBase<S>
     }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SignalLinkBase
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class SignalLinkBase : public SignalBase<S>
+{
+public:
+    using SignalBase::SignalBase;
+
+protected:
+    SignalLinkBase() = default;
+
+    SignalLinkBase(const SignalLinkBase&) = default;
+    SignalLinkBase& operator=(const SignalLinkBase&) = default;
+
+    SignalLinkBase(SignalLinkBase&&) = default;
+    SignalLinkBase& operator=(SignalLinkBase&&) = default;
+
+    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const SignalBase<S>& input) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using LinkNodeType = REACT_IMPL::SignalLinkNode<S>;
+
+        auto node = std::make_shared<LinkNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
+				node->SetWeakSelfPtr(std::weak_ptr<LinkNodeType>{ node });
+				return node;
+    }
+
+		friend struct REACT_IMPL::PrivateSignalLinkNodeInterface;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -227,10 +266,16 @@ class Signal<S, unique> : public SignalBase<S>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
-    // Construct func signal
+    // Construct func signal with explicit group
+    template <typename F, typename ... Ts>
+    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), deps ...) )
+        { }
+
+		// Construct func signal with implicit group
     template <typename F, typename ... Ts>
     explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::NodeCtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
         { }
 };
 
@@ -250,12 +295,6 @@ class Signal<S, shared> : public SignalBase<S>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
-    // Construct func signal
-    template <typename F, typename ... Ts>
-    explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::NodeCtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
-        { }
-
     // Construct from unique
     Signal(Signal<S, unique>&& other) :
         Signal::SignalBase( std::move(other) )
@@ -264,6 +303,18 @@ class Signal<S, shared> : public SignalBase<S>
     // Assign from unique
     Signal& operator=(Signal<S, unique>&& other)
         { Signal::SignalBase::operator=(std::move(other)); return *this; }
+
+		// Construct func signal with explicit group
+    template <typename F, typename ... Ts>
+    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
+        { }
+
+    // Construct func signal with implicit group
+    template <typename F, typename ... Ts>
+    explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), deps ...) )
+        { }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -285,16 +336,15 @@ class VarSignal<S, unique> : public VarSignalBase<S>
     VarSignal(VarSignal&&) = default;
     VarSignal& operator=(VarSignal&&) = default;
 
-    // Construct with default
-    template <typename TGroup>
-    explicit VarSignal(const TGroup& group) :
-        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode( group) )
+    // Construct with group + default
+    explicit VarSignal(const ReactiveGroupBase& group) :
+        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 
-    // Construct with value
-    template <typename T, typename TGroup>
-    VarSignal(T&& value, const TGroup& group) :
-        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode(std::forward<T>(value), group) )
+    // Construct with group + value
+    template <typename T>
+    VarSignal(const ReactiveGroupBase& group, T&& value) :
+        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value)) )
         { }
 };
 
@@ -324,15 +374,14 @@ class VarSignal<S, shared> : public VarSignalBase<S>
         { VarSignal::VarSignalBase::operator=(std::move(other)); return *this; }
 
     // Construct with default
-    template <typename TGroup>
-    explicit VarSignal(const TGroup& group) :
-        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode( group) )
+    explicit VarSignal(const ReactiveGroupBase& group) :
+        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 
     // Construct with value
-    template <typename T, typename TGroup>
-    VarSignal(T&& value, const TGroup& group) :
-        VarSignal::VarSignalBase( REACT_IMPL::NodeCtorTag{ }, CreateVarNode(std::forward<T>(value), group) )
+    template <typename T>
+    VarSignal(const ReactiveGroupBase& group, T&& value) :
+        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value)) )
         { }
 };
 
@@ -355,14 +404,19 @@ class SignalSlot<S, unique> : public SignalSlotBase<S>
     SignalSlot(SignalSlot&&) = default;
     SignalSlot& operator=(SignalSlot&&) = default;
 
-    // Construct with default
+    // Construct with group + default
     explicit SignalSlot(const ReactiveGroupBase& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode( group) )
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 
-    // Construct with value
-    SignalSlot(const SignalBase<S>& input, const ReactiveGroupBase& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+    // Construct with group + value
+    SignalSlot(const ReactiveGroupBase& group, const SignalBase<S>& input) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
+
+		// Construct with value
+    explicit SignalSlot(const SignalBase<S>& input) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
         { }
 };
 
@@ -391,14 +445,90 @@ class SignalSlot<S, shared> : public SignalSlotBase<S>
     SignalSlot& operator=(SignalSlot<S, unique>&& other)
         { SignalSlot::SignalSlotBase::operator=(std::move(other)); return *this; }
 
-    // Construct with default
+    // Construct with group + default
     explicit SignalSlot(const ReactiveGroupBase& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode( group) )
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        { }
+
+    // Construct with group + value
+    SignalSlot(const ReactiveGroupBase& group, const SignalBase<S>& input) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
+
+		// Construct with value
+    explicit SignalSlot(const SignalBase<S>& input) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        { }
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SignalLink
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class SignalLink<S, unique> : public SignalLinkBase<S>
+{
+public:
+    using SignalLinkBase::SignalLinkBase;
+
+    using ValueType = S;
+
+    SignalLink() = delete;
+
+    SignalLink(const SignalLink&) = delete;
+    SignalLink& operator=(const SignalLink&) = delete;
+
+    SignalLink(SignalLink&&) = default;
+    SignalLink& operator=(SignalLink&&) = default;
+
+    // Construct with default
+    explicit SignalLink(const ReactiveGroupBase& group) :
+        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        { }
+
+    // Construct with group + value
+    SignalLink(const ReactiveGroupBase& group, const SignalBase<S>& input) :
+        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
+
+		// Construct with value
+    explicit SignalLink(const SignalBase<S>& input) :
+        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        { }
+};
+
+template <typename S>
+class SignalLink<S, shared> : public SignalLinkBase<S>
+{
+public:
+    using SignalLinkBase::SignalLinkBase;
+
+    using ValueType = S;
+
+    SignalLink() = delete;
+
+    SignalLink(const SignalLink&) = default;
+    SignalLink& operator=(const SignalLink&) = default;
+
+    SignalLink(SignalLink&&) = default;
+    SignalLink& operator=(SignalLink&&) = default;
+
+    // Construct from unique
+    SignalLink(SignalLink<S, unique>&& other) :
+        SignalLink::SignalLinkBase( std::move(other) )
+        { }
+
+    // Assign from unique
+    SignalLink& operator=(SignalSlot<S, unique>&& other)
+        { SignalLink::SignalLinkBase::operator=(std::move(other)); return *this; }
+
+    // Construct with default
+    explicit SignalLink(const ReactiveGroupBase& group) :
+        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 
     // Construct with value
-    SignalSlot(const SignalBase<S>& input, const ReactiveGroupBase& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::NodeCtorTag{ }, CreateSlotNode(input, group) )
+    SignalLink(const ReactiveGroupBase& group, const SignalBase<S>& input) :
+        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 };
 
@@ -412,6 +542,24 @@ bool Equals(const SignalBase<L>& lhs, const SignalBase<R>& rhs)
     return lhs.Equals(rhs);
 }
 
+struct PrivateSignalLinkNodeInterface
+{
+	template <typename S>
+	static auto GetLocalSignalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const SignalBase<S>& sig) -> std::shared_ptr<SignalNode<S>>
+	{
+		const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(sig);
+
+		if (sourceGraph == targetGraph)
+		{
+			return PrivateNodeInterface::NodePtr(sig);
+		}
+		else
+		{
+			return SignalLinkBase<S>::CreateLinkNode(targetGraph, sig);
+		}
+	}
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/IReactiveGraph.h
index 594f3801..2ac8f291 100644
--- a/include/react/detail/IReactiveGraph.h
+++ b/include/react/detail/IReactiveGraph.h
@@ -13,7 +13,7 @@
 
 #include <functional>
 #include <memory>
-#include <unordered_set>
+#include <unordered_map>
 #include <utility>
 
 #include "react/API.h"
@@ -45,7 +45,7 @@ enum class NodeCategory
     input,
     dyninput,
     output,
-    link
+    linkoutput
 };
 
 class ReactiveGraph;
@@ -64,11 +64,11 @@ struct IReactiveNode
     virtual int GetDependencyCount() const = 0;
 };
 
-using LinkOutputList = std::vector<std::pair<ReactiveGraph*, IReactiveNode*>>;
+using LinkOutputMap = std::unordered_map<ReactiveGraph*, std::vector<std::function<void()>>>;
 
 struct ILinkOutputNode : public IReactiveNode
 {
-    virtual void CollectOutput(LinkOutputList& output) = 0;
+    virtual void CollectOutput(LinkOutputMap& output) = 0;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 6a457a98..f188e55c 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -469,7 +469,8 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 
             // All slots ready?
             apply(
-                [this, &isReady] (Slot<Ts>& ... slots) {
+                [this, &isReady] (Slot<Ts>& ... slots)
+								{
                     // Todo: combine return values instead
                     REACT_EXPAND_PACK(CheckSlot(slots, isReady));
                 },
@@ -534,6 +535,104 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     std::tuple<Slot<Ts>...> slots_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventLinkNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E>
+class EventLinkNode : public EventStreamNode<E>
+{
+public:
+    EventLinkNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<ReactiveGraph>& srcGraphPtr, const std::shared_ptr<EventStreamNode<E>>& dep) :
+        EventLinkNode::EventStreamNode( graphPtr ),
+        linkOutput_( srcGraphPtr, dep )
+    {
+        this->RegisterMe(NodeCategory::input);
+    }
+
+    ~EventLinkNode()
+    {
+        this->UnregisterMe();
+    }
+
+		void SetWeakSelfPtr(const std::weak_ptr<EventLinkNode>& self)
+				{	linkOutput_.parent = self; }
+
+    virtual const char* GetNodeType() const override
+        { return "EventLink"; }
+
+    virtual int GetDependencyCount() const override
+        { return 1; }
+
+    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+		{
+				this->SetPendingSuccessorCount(successorCount);
+				return UpdateResult::changed;
+		}
+
+    void SetEvents(EventLinkNode::EventStreamNode::StorageType&& events)
+        { this->Events() = std::move(events); }
+
+private:
+    struct VirtualOutputNode : public ILinkOutputNode
+    {
+        VirtualOutputNode(const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<EventStreamNode<E>>& depIn) :
+						parent( ),
+            srcGraphPtr( srcGraphPtrIn ),
+            dep( depIn )
+        {
+					nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
+					srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
+				}
+
+				~VirtualOutputNode()
+				{
+						srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
+						srcGraphPtr->UnregisterNode(nodeId);
+				}
+
+        virtual const char* GetNodeType() const override
+            { return "EventLinkOutput"; }
+
+        virtual int GetDependencyCount() const override
+            { return 1; }
+
+        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        {            
+						return UpdateResult::changed;
+        }
+
+        virtual void CollectOutput(LinkOutputMap& output) override
+        {
+					if (auto p = parent.lock())
+					{
+						auto* rawPtr = p->GraphPtr().get();
+						output[rawPtr].push_back(
+							[storedParent = std::move(p), storedEvents = dep->Events()] () mutable
+							{
+								NodeId nodeId = storedParent->GetNodeId();
+								auto& graphPtr = storedParent->GraphPtr();
+
+								graphPtr->AddInput(nodeId,
+									[&storedParent, &storedEvents]
+									{
+										storedParent->SetEvents(std::move(storedEvents));
+									});
+							});
+					}
+				}
+
+				std::weak_ptr<EventLinkNode> parent;
+
+        NodeId nodeId;
+
+        std::shared_ptr<EventStreamNode<E>> dep;
+
+        std::shared_ptr<ReactiveGraph> srcGraphPtr;
+    };
+
+    VirtualOutputNode linkOutput_;
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_EVENTNODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index e0eb2f59..182cfcd0 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -44,6 +44,8 @@ class TransactionQueue
     template <typename F>
     void Push(TransactionFlags flags, F&& transaction)
     {
+				transactions_.push(StoredTransaction{ flags, std::forward<F>(transaction) });
+
         if (count_.fetch_add(1, std::memory_order_relaxed) == 0)
             tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(*this));
     }
@@ -95,9 +97,6 @@ class ReactiveGraph
     void OnDynamicNodeAttach(NodeId node, NodeId parentId, TurnId turnId);
     void OnDynamicNodeDetach(NodeId node, NodeId parentId, TurnId turnId);
 
-    LinkId AddGroupLink(ILinkNodeOutput* nodePtr, NodeCategory category);
-    void RemoveGroupLink(LinkId nodeId);
-
     template <typename F>
     void AddInput(NodeId nodeId, F&& inputCallback);
 
@@ -118,7 +117,7 @@ class ReactiveGraph
         NodeData(IReactiveNode* nodePtrIn, NodeCategory categoryIn) :
             nodePtr( nodePtrIn ),
             category(categoryIn)
-        { }
+						{ }
 
         NodeCategory category = NodeCategory::normal;
 
@@ -127,7 +126,6 @@ class ReactiveGraph
         bool    queued      = false;
 
         IReactiveNode*  nodePtr = nullptr;
-        
 
         std::vector<NodeId> successors;
     };
@@ -167,7 +165,7 @@ class ReactiveGraph
     TopoQueue           scheduledNodes_;
     IndexMap<NodeData>  nodeData_;
     std::vector<NodeId> changedInputs_;
-    std::vector<NodeId> scheduledLinkNodes_;
+    LinkOutputMap				scheduledLinkOutputs_;
 
     bool isTransactionActive_ = false;
 };
@@ -239,6 +237,9 @@ void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
 
             if (! scheduledNodes_.IsEmpty())
                 Propagate();
+
+						if (! scheduledLinkOutputs_.empty())
+								UpdateLinkNodes();
         }
     }
 }
@@ -274,7 +275,7 @@ void ReactiveGraph::DoTransaction(F&& transactionCallback)
     if (! scheduledNodes_.IsEmpty())
         Propagate();
 
-    if (!scheduledLinkNodes_.empty())
+    if (! scheduledLinkOutputs_.empty())
         UpdateLinkNodes();
 }
 
@@ -302,6 +303,13 @@ void ReactiveGraph::Propagate()
                 continue;
             }
 
+						// Special handling for link output nodes. They have no successors and they don't have to be updated.
+						if (node.category == NodeCategory::linkoutput)
+						{
+							static_cast<ILinkOutputNode*>(node.nodePtr)->CollectOutput(scheduledLinkOutputs_);
+							continue;
+						}
+
             int successorCount = node.successors.size();
 
             if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
@@ -316,10 +324,35 @@ void ReactiveGraph::Propagate()
 
 void ReactiveGraph::UpdateLinkNodes()
 {
-    for (const auto& x : scheduledLinkNodes_)
-    {
-
-    }
+	for (auto& e : scheduledLinkOutputs_)
+	{
+		e.first->EnqueueTransaction(TransactionFlags::none,
+			[inputs = std::move(e.second)]
+			{
+				for (auto& callback : inputs)
+					callback();
+			});
+	}
+
+	scheduledLinkOutputs_.clear();
+
+	/*using ElementType = std::pair<ReactiveGraph*, IReactiveNode*>;
+
+	auto from = scheduledLinkOutputs_.begin();
+	auto to = scheduledLinkOutputs_.end();
+
+	for (auto it = from; it != to; ++it)
+	{
+		ReactiveGraph* graphPtr = it->first;
+		auto p = std::partition(it, to, [=] (ReactiveGraph* e) { return e == graphPtr });
+
+		for (auto it2 = p; it2 != to; ++it2)
+		{
+			graphPtr->EnqueueLinkTransaction();
+		}
+	}
+
+	scheduledLinkOutputs_.clear();*/
 }
 
 void ReactiveGraph::ScheduleSuccessors(NodeData& node)
@@ -331,11 +364,7 @@ void ReactiveGraph::ScheduleSuccessors(NodeData& node)
         if (!succ.queued)
         {
             succ.queued = true;
-
-            if (node.category != NodeCategory::link)
-                scheduledNodes_.Push(succId, succ.level);
-            else
-                scheduledLinkNodes_.push_back(succId);
+						scheduledNodes_.Push(succId, succ.level);
         }
     }
 }
@@ -400,7 +429,7 @@ size_t TransactionQueue::ProcessNextBatch()
     {
         if (!skipPop)
         {
-            if (transactions_.try_pop(curTransaction))
+            if (!transactions_.try_pop(curTransaction))
                 return popCount;
 
             canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 2bdd3eac..d084945d 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -267,7 +267,7 @@ class SignalSlotNode : public SignalNode<S>
             { }
 
         virtual const char* GetNodeType() const override
-            { return "SignalSlotVirtualInput"; }
+            { return "SignalSlotInput"; }
 
         virtual int GetDependencyCount() const override
             { return 0; }
@@ -301,7 +301,7 @@ class SignalSlotNode : public SignalNode<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalBridgeNode
+/// SignalLinkNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
 class SignalLinkNode : public SignalNode<S>
@@ -309,85 +309,95 @@ class SignalLinkNode : public SignalNode<S>
 public:
     SignalLinkNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<ReactiveGraph>& srcGraphPtr, const std::shared_ptr<SignalNode<S>>& dep) :
         SignalLinkNode::SignalNode( graphPtr, dep->Value() ),
-        linkOutput_( *this, srcGraphPtr, dep )
+        linkOutput_( srcGraphPtr, dep )
     {
-        slotInput_.nodeId = GraphPtr()->RegisterNode(&linkOutput_, NodeCategory::dyninput);
-        this->RegisterMe();
-
-        this->AttachToMe(slotInput_.nodeId);
-        this->AttachToMe(dep->GetNodeId());
+        this->RegisterMe(NodeCategory::input);
     }
 
     ~SignalLinkNode()
     {
-        this->DetachFromMe(slotInput_.dep->GetNodeId());
-        this->DetachFromMe(slotInput_.nodeId);
-
         this->UnregisterMe();
-        GraphPtr()->UnregisterNode(slotInput_.nodeId);
     }
 
+		void SetWeakSelfPtr(const std::weak_ptr<SignalLinkNode>& self)
+				{	linkOutput_.parent = self; }
+
     virtual const char* GetNodeType() const override
         { return "SignalLink"; }
 
     virtual int GetDependencyCount() const override
-        { return 2; }
+        { return 1; }
 
     virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
-        {// outputDataMutex
-            std::lock_guard lock(linkOutput_.outputDataMutex);
-            this->Value() = std::move(linkOutput_.outputData.front());
-            linkOutput_.outputData.pop();
-        }// ~outputDataMutex
-
         return UpdateResult::changed;
     }
 
+    template <typename T>
+    void SetValue(T&& newValue)
+    {
+        this->Value() = std::forward<T>(newValue);
+    }
+
 private:
     struct VirtualOutputNode : public ILinkOutputNode
     {
-        VirtualOutputNode(SignalSlotNode& parentIn, const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<SignalNode<S>>& depIn) :
-            parent( parentIn ),
-            srcGraphPtr(srcGraphPtrIn),
+        VirtualOutputNode(const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<SignalNode<S>>& depIn) :
+						parent( ),
+            srcGraphPtr( srcGraphPtrIn ),
             dep( depIn )
-            { }
+        {
+					nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
+					srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
+				}
+
+				~VirtualOutputNode()
+				{
+						srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
+						srcGraphPtr->UnregisterNode(nodeId);
+				}
 
         virtual const char* GetNodeType() const override
-            { return "SignalLinkVirtualOutput"; }
+            { return "SignalLinkOutput"; }
 
         virtual int GetDependencyCount() const override
             { return 1; }
 
         virtual UpdateResult Update(TurnId turnId, int successorCount) override
-        {
-            {// outputDataMutex
-                std::lock_guard lock(outputDataMutex);
-                outputData.push(dep->Value());
-            }// ~outputDataMutex
-            
+        {   
             return UpdateResult::changed;
         }
 
-        virtual void CollectOutput(LinkOutputList& output) override
-            { output.emplace_back(srcGraphPtr.get(), &parent); }
-
-        SignalSlotNode& parent;
+        virtual void CollectOutput(LinkOutputMap& output) override
+        {
+					if (auto p = parent.lock())
+					{
+						auto* rawPtr = p->GraphPtr().get();
+						output[rawPtr].push_back(
+							[storedParent = std::move(p), storedValue = dep->Value()]
+							{
+								NodeId nodeId = storedParent->GetNodeId();
+								auto& graphPtr = storedParent->GraphPtr();
+
+								graphPtr->AddInput(nodeId,
+									[&storedParent, &storedValue]
+									{
+										storedParent->SetValue(std::move(storedValue));
+									});
+							});
+					}
+				}
+
+				std::weak_ptr<SignalLinkNode> parent;
 
         NodeId nodeId;
 
         std::shared_ptr<SignalNode<S>> dep;
 
-        std::mutex outputDataMutex;
-
-        std::queue<S, std::vector<S>> outputData;
-
         std::shared_ptr<ReactiveGraph> srcGraphPtr;
     };
 
     VirtualOutputNode linkOutput_;
-
-    
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/

From 96302158e61ec39130db3082b048756417714a98 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 11 Dec 2016 23:16:34 +0100
Subject: [PATCH 37/75] group progress

---
 examples/src/Main.cpp                      |  28 ++--
 include/react/API.h                        |   6 -
 include/react/Algorithm.h                  | 178 ++++++++++++++++++---
 include/react/Event.h                      |  50 +++---
 include/react/Group.h                      |   1 -
 include/react/Observer.h                   |  27 ++--
 include/react/Signal.h                     |  52 +++---
 include/react/detail/ReactiveInput.h       |   7 +-
 include/react/detail/graph/EventNodes.h    |  72 ++++-----
 include/react/detail/graph/ObserverNodes.h |   2 +-
 include/react/detail/graph/SignalNodes.h   |  60 +++----
 11 files changed, 304 insertions(+), 179 deletions(-)

diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 62d5c079..e4fe6f5d 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -45,12 +45,20 @@ template <typename T> void PrintEvents(EventRange<T> evts)
 		printf("  Event: %d\n", e);
 }
 
+template <typename T> void PrintSyncedEvents(EventRange<T> evts, int a, int b)
+{
+	printf("Processing events...\n");
+
+	for (const auto& e : evts)
+		printf("  Event: %d, %d, %d\n", e, a, b);
+}
+
 template <typename T> bool FilterFunc(T v)
 {
 	return v > 10;
 }
 
-int main2()
+int main()
 {
 	ReactiveGroup<> group;
 
@@ -60,7 +68,7 @@ int main2()
 		VarSignal<int> y{ group, 0 };
 		VarSignal<int> z{ group, 0 };
 
-		Signal<int> area{ Multiply<int>, x, y };
+		Signal<int> area{ group, Multiply<int>, x, y };
 		Signal<int> volume{ Multiply<int>, area, z };
 
 		Observer<> areaObs{ PrintArea<int>, area };
@@ -136,15 +144,21 @@ int main2()
 		ReactiveGroup<> group1;
 		ReactiveGroup<> group2;
 
+        VarSignal<int> s1{ group1, 10 };
+		VarSignal<int> s2{ group2, 11 };
+
 		EventSource<int> e1{ group1 };
 		EventSource<int> e2{ group2 };
 
+        auto hold = Hold(group1, 0, e1);
+
 		auto merged = Merge(group2, e1, e2);
 
 		auto joined = Join(e1, e2);
 		auto joined2 = Join(group1, e1, e2);
 
 		Observer<> eventObs{ PrintEvents<int>, merged };
+        Observer<> eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
 
 		e1.Emit(222);
 
@@ -154,16 +168,6 @@ int main2()
 	return 0;
 }
 
-int main()
-{
-	ReactiveGroup<> group;
-
-	VarSignal<int> a{  };
-	VarSignal<int> b{  };
-
-}
-
-
 
 
 
diff --git a/include/react/API.h b/include/react/API.h
index 79a44241..b1e86ad1 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -23,12 +23,6 @@ enum OwnershipPolicy
     shared
 };
 
-enum ReferencePolicy
-{
-    strong,
-    weak
-};
-
 enum class WeightHint
 {
     automatic,
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index af6bce46..9a033559 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -18,47 +18,107 @@
 #include "react/API.h"
 #include "react/detail/graph/AlgorithmNodes.h"
 
+#include "Event.h"
+#include "Signal.h"
+
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Hold - Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, typename E>
-auto Hold(T&& initialValue, const EventBase<E>& events) -> Signal<E, unique>
+auto Hold(const ReactiveGroupBase& group, T&& initialValue, const EventBase<E>& evnt) -> Signal<E, unique>
 {
     using REACT_IMPL::HoldNode;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Signal<E, unique>( CtorTag{ }, std::make_shared<HoldNode<E>>(
+        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+}
+
+template <typename T, typename E>
+auto Hold(T&& initialValue, const EventBase<E>& evnt) -> Signal<E, unique>
+{
+    using REACT_IMPL::HoldNode;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
 
-    return Signal<E, unique>( NodeCtorTag{ }, std::make_shared<HoldNode<E>>(
-        PrivateNodeInterface::GraphPtr(events), std::forward<T>(initialValue), PrivateNodeInterface::NodePtr(events)) );
+    return Signal<E, unique>( CtorTag{ }, std::make_shared<HoldNode<E>>(
+        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Monitor - Emits value changes of target signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+auto Monitor(const ReactiveGroupBase& group, const SignalBase<S>& signal) -> Event<S, unique>
+{
+    using REACT_IMPL::MonitorNode;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Event<S, unique>( CtorTag{ }, std::make_shared<MonitorNode<S>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal)) );
+}
+
 template <typename S>
 auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
 {
     using REACT_IMPL::MonitorNode;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
 
-    return Event<S, unique>( NodeCtorTag{ }, std::make_shared<MonitorNode<S>>(
-        PrivateNodeInterface::GraphPtr(signal), PrivateNodeInterface::NodePtr(signal)) );
+    return Event<S, unique>( CtorTag{ }, std::make_shared<MonitorNode<S>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E>
-auto Iterate(T&& init, F&& func, const EventBase<E>& events) -> Signal<S, unique>
+auto Iterate(const ReactiveGroupBase& group, T&& initialValue, F&& func, const EventBase<E>& evnt) -> Signal<S, unique>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
     using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    using FuncType = typename std::decay<F>::type;
+    using IterNodeType = typename std::conditional<
+        IsCallableWith<F,S,EventRange<E>,S>::value,
+        IterateNode<S, FuncType, E>,
+        IterateByRefNode<S, FuncType, E>>::type;
+
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
+        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt) ));
+}
+
+template <typename S, typename T, typename F, typename E>
+auto Iterate(T&& initialValue, F&& func, const EventBase<E>& evnt) -> Signal<S, unique>
+{
+    using REACT_IMPL::IterateNode;
+    using REACT_IMPL::IterateByRefNode;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+    using REACT_IMPL::CtorTag;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -66,22 +126,49 @@ auto Iterate(T&& init, F&& func, const EventBase<E>& events) -> Signal<S, unique
         IterateNode<S, FuncType, E>,
         IterateByRefNode<S, FuncType, E>>::type;
 
-    return Signal<S, unique>( NodeCtorTag{ }, std::make_shared<IterNodeType>(
-        PrivateNodeInterface::GraphPtr(events), std::forward<T>(init), std::forward<F>(func), PrivateNodeInterface::NodePtr(events) ));
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
+
+    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
+        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt) ));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto Iterate(T&& init, F&& func, const EventBase<E>& events, const SignalBase<Us>& ... signals) -> Signal<S, unique>
+auto Iterate(const ReactiveGroupBase& group, T&& initialValue, F&& func, const EventBase<E>& evnt, const SignalBase<Us>& ... signals) -> Signal<S, unique>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
     using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    using FuncType = typename std::decay<F>::type;
+    using IterNodeType = typename std::conditional<
+        IsCallableWith<F, S, EventRange<E>, S, Us ...>::value,
+        SyncedIterateNode<S, FuncType, E, Us ...>,
+        SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
+
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
+        graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
+        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...));
+}
+
+template <typename S, typename T, typename F, typename E, typename ... Us>
+auto Iterate(T&& initialValue, F&& func, const EventBase<E>& evnt, const SignalBase<Us>& ... signals) -> Signal<S, unique>
+{
+    using REACT_IMPL::SyncedIterateNode;
+    using REACT_IMPL::SyncedIterateByRefNode;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+    using REACT_IMPL::CtorTag;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -89,38 +176,77 @@ auto Iterate(T&& init, F&& func, const EventBase<E>& events, const SignalBase<Us
         SyncedIterateNode<S, FuncType, E, Us ...>,
         SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
 
-    return Signal<S, unique>( NodeCtorTag{ }, std::make_shared<IterNodeType>(
-        GetCheckedGraphPtr(events, signals ...),
-        std::forward<T>(init), std::forward<F>(func), PrivateNodeInterface::NodePtr(events), PrivateNodeInterface::NodePtr(signals) ...));
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
+
+    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
+        graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
+        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& trigger) -> Signal<S, unique>
+auto Snapshot(const ReactiveGroupBase& group, const SignalBase<S>& signal, const EventBase<E>& evnt) -> Signal<S, unique>
 {
     using REACT_IMPL::SnapshotNode;
-    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Event<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
+        graphPtr, PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(evnt)) );
+}
+
+template <typename S, typename E>
+auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& evnt) -> Signal<S, unique>
+{
+    using REACT_IMPL::SnapshotNode;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::NodeCtorTag;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
-    return Events<S, unique>( NodeCtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
-        GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
+    return Event<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Pulse - Emits value of target signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Pulse(const SignalBase<S>& signal, const EventBase<E>& trigger) -> Event<S, unique>
+auto Pulse(const ReactiveGroupBase& group, const SignalBase<S>& signal, const EventBase<E>& evnt) -> Event<S, unique>
 {
     using REACT_IMPL::PulseNode;
-    using REACT_IMPL::GetCheckedGraphPtr;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;;
+    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+
+    return Event<S, unique>( CtorTag{ }, std::make_shared<PulseNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::NodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::NodePtr(graphPtr, evnt)) );
+}
+
+template <typename S, typename E>
+auto Pulse(const SignalBase<S>& signal, const EventBase<E>& evnt) -> Event<S, unique>
+{
+    using REACT_IMPL::PulseNode;
+    using REACT_IMPL::PrivateSignalLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::CtorTag;
+
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
-    return Event<S, unique>( NodeCtorTag{ }, std::make_shared<PulseNode<S, E>>(
-        GetCheckedGraphPtr(signal, trigger), PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(trigger)) );
+    return Event<S, unique>( CtorTag{ }, std::make_shared<PulseNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
 }
 
 /******************************************/ REACT_END /******************************************/
diff --git a/include/react/Event.h b/include/react/Event.h
index 89bcc0c8..bf8c0a05 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -230,11 +230,11 @@ class EventLinkBase : public EventBase<E>
         using EventNodeType = REACT_IMPL::EventLinkNode<E>;
 
         auto node = std::make_shared<EventNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
-				node->SetWeakSelfPtr(std::weak_ptr<EventNodeType>{ node });
-				return node;
+        node->SetWeakSelfPtr(std::weak_ptr<EventNodeType>{ node });
+        return node;
     }
 
-		friend struct REACT_IMPL::PrivateEventLinkNodeInterface;
+    friend struct REACT_IMPL::PrivateEventLinkNodeInterface;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -315,7 +315,7 @@ class Event<E, shared> : public EventBase<E>
         Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
         { }
 
-		template <typename F, typename T, typename ... Us>
+    template <typename F, typename T, typename ... Us>
     Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
         Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
         { }
@@ -452,10 +452,10 @@ auto Merge(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const Even
         typename std::common_type<U1, Us ...>::type,
         T>::type;
 
-		const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
     return Event<E, unique>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
 }
 
 template <typename T = void, typename U1, typename ... Us>
@@ -477,7 +477,7 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
     return Event<E, unique>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -591,7 +591,7 @@ auto Join(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const Event
 {
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::PrivateReactiveGroupInterface;
-		using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::CtorTag;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
@@ -600,7 +600,7 @@ auto Join(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const Event
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
     return Event<std::tuple<U1, Us ...>, unique>( CtorTag{ }, std::make_shared<EventJoinNode<U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
 }
 
 template <typename U1, typename ... Us>
@@ -608,7 +608,7 @@ auto Join(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> Event<std
 {
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::PrivateNodeInterface;
-		using REACT_IMPL::PrivateEventLinkNodeInterface;
+    using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::CtorTag;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
@@ -617,7 +617,7 @@ auto Join(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> Event<std
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
     return Event<std::tuple<U1, Us ...>, unique>( CtorTag{ }, std::make_shared<EventJoinNode<U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, deps) ...));
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -649,20 +649,20 @@ bool Equals(const EventBase<L>& lhs, const EventBase<R>& rhs)
 
 struct PrivateEventLinkNodeInterface
 {
-	template <typename E>
-	static auto GetLocalEventNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const EventBase<E>& dep) -> std::shared_ptr<EventStreamNode<E>>
-	{
-		const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(dep);
-
-		if (sourceGraph == targetGraph)
-		{
-			return PrivateNodeInterface::NodePtr(dep);
-		}
-		else
-		{
-			return EventLinkBase<E>::CreateLinkNode(targetGraph, dep);
-		}
-	}
+    template <typename E>
+    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const EventBase<E>& dep) -> std::shared_ptr<EventStreamNode<E>>
+    {
+        const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(dep);
+
+        if (sourceGraph == targetGraph)
+        {
+            return PrivateNodeInterface::NodePtr(dep);
+        }
+        else
+        {
+            return EventLinkBase<E>::CreateLinkNode(targetGraph, dep);
+        }
+    }
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/Group.h b/include/react/Group.h
index ac5c1b91..fc5e49f1 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -22,7 +22,6 @@
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 struct PrivateReactiveGroupInterface;
-struct PrivateConcurrentReactiveGroupInterface;
 struct CtorTag { };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 590c5baa..eea9ce5f 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -58,13 +58,13 @@ class ObserverBase
     template <typename F, typename T1, typename ... Ts>
     auto CreateSignalObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-				using REACT_IMPL::PrivateSignalLinkNodeInterface;
+        using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<ObsNodeType>(
             graphPtr,
             std::forward<F>(func),
-            PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, deps) ...);
+            PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
     }
 
     template <typename F, typename T1, typename ... Ts>
@@ -77,30 +77,35 @@ class ObserverBase
     template <typename F, typename T>
     auto CreateEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const EventBase<T>& dep) -> decltype(auto)
     {
-				using REACT_IMPL::PrivateEventLinkNodeInterface;
+        using REACT_IMPL::PrivateEventLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::EventObserverNode<typename std::decay<F>::type, T>;
 
-        return std::make_shared<ObsNodeType>(graphPtr, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalEventNodePtr(graphPtr, dep));
+        return std::make_shared<ObsNodeType>(graphPtr, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep));
     }
 
     template <typename F, typename T>
     auto CreateEventObserverNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
-        return CreateSignalObserverNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
+        return CreateEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep);
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
-				using REACT_IMPL::PrivateSignalLinkNodeInterface;
+        using REACT_IMPL::PrivateEventLinkNodeInterface;
+        using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>;
 
-				const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep);
-
         return std::make_shared<ObsNodeType>(
-            graphPtr, std::forward<F>(func), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, dep), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, syncs) ...);
+            graphPtr, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, syncs) ...);
+    }
+
+    template <typename F, typename T, typename ... Us>
+    auto CreateSyncedEventObserverNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
+    {
+        using REACT_IMPL::PrivateNodeInterface;
+        return CreateSyncedEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep, syncs ...);
     }
 
 private:
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 4f733f47..bd5f62df 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -68,20 +68,20 @@ class SignalBase
     template <typename F, typename T1, typename ... Ts>
     auto CreateFuncNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-				using REACT_IMPL::PrivateSignalLinkNodeInterface;
+        using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using FuncNodeType = REACT_IMPL::SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<FuncNodeType>(
             graphPtr,
             std::forward<F>(func),
-            PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalSignalNodePtr(graphPtr, deps) ...);
+            PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
     }
 
     template <typename F, typename T1, typename ... Ts>
     auto CreateFuncNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
     {
-			using REACT_IMPL::PrivateNodeInterface;
-			return CreateFuncNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
+        using REACT_IMPL::PrivateNodeInterface;
+        return CreateFuncNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
     }
 
 private:
@@ -240,11 +240,11 @@ class SignalLinkBase : public SignalBase<S>
         using LinkNodeType = REACT_IMPL::SignalLinkNode<S>;
 
         auto node = std::make_shared<LinkNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
-				node->SetWeakSelfPtr(std::weak_ptr<LinkNodeType>{ node });
-				return node;
+        node->SetWeakSelfPtr(std::weak_ptr<LinkNodeType>{ node });
+        return node;
     }
 
-		friend struct REACT_IMPL::PrivateSignalLinkNodeInterface;
+    friend struct REACT_IMPL::PrivateSignalLinkNodeInterface;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -272,7 +272,7 @@ class Signal<S, unique> : public SignalBase<S>
         Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), deps ...) )
         { }
 
-		// Construct func signal with implicit group
+    // Construct func signal with implicit group
     template <typename F, typename ... Ts>
     explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
         Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
@@ -304,7 +304,7 @@ class Signal<S, shared> : public SignalBase<S>
     Signal& operator=(Signal<S, unique>&& other)
         { Signal::SignalBase::operator=(std::move(other)); return *this; }
 
-		// Construct func signal with explicit group
+    // Construct func signal with explicit group
     template <typename F, typename ... Ts>
     explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... deps) :
         Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
@@ -414,7 +414,7 @@ class SignalSlot<S, unique> : public SignalSlotBase<S>
         SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 
-		// Construct with value
+    // Construct with value
     explicit SignalSlot(const SignalBase<S>& input) :
         SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
         { }
@@ -455,7 +455,7 @@ class SignalSlot<S, shared> : public SignalSlotBase<S>
         SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 
-		// Construct with value
+    // Construct with value
     explicit SignalSlot(const SignalBase<S>& input) :
         SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
         { }
@@ -490,7 +490,7 @@ class SignalLink<S, unique> : public SignalLinkBase<S>
         SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 
-		// Construct with value
+    // Construct with value
     explicit SignalLink(const SignalBase<S>& input) :
         SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
         { }
@@ -544,20 +544,20 @@ bool Equals(const SignalBase<L>& lhs, const SignalBase<R>& rhs)
 
 struct PrivateSignalLinkNodeInterface
 {
-	template <typename S>
-	static auto GetLocalSignalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const SignalBase<S>& sig) -> std::shared_ptr<SignalNode<S>>
-	{
-		const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(sig);
-
-		if (sourceGraph == targetGraph)
-		{
-			return PrivateNodeInterface::NodePtr(sig);
-		}
-		else
-		{
-			return SignalLinkBase<S>::CreateLinkNode(targetGraph, sig);
-		}
-	}
+    template <typename S>
+    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const SignalBase<S>& sig) -> std::shared_ptr<SignalNode<S>>
+    {
+        const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(sig);
+
+        if (sourceGraph == targetGraph)
+        {
+            return PrivateNodeInterface::NodePtr(sig);
+        }
+        else
+        {
+            return SignalLinkBase<S>::CreateLinkNode(targetGraph, sig);
+        }
+    }
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/ReactiveInput.h b/include/react/detail/ReactiveInput.h
index dd2d101c..d156b9fb 100644
--- a/include/react/detail/ReactiveInput.h
+++ b/include/react/detail/ReactiveInput.h
@@ -654,8 +654,7 @@ class InputManager :
     }
 
     template <typename F>
-    void AsyncTransaction(TransactionFlagsT flags, const WaitingStatePtrT& waitingStatePtr,
-                          F&& func)
+    void AsyncTransaction(TransactionFlagsT flags, const WaitingStatePtrT& waitingStatePtr, F&& func)
     {
         if (waitingStatePtr != nullptr)
             waitingStatePtr->IncWaitCount();
@@ -693,9 +692,7 @@ class InputManager :
     }
 
     //IContinuationTarget        
-    virtual void AsyncContinuation(TransactionFlagsT flags,
-                                   const WaitingStatePtrT& waitingStatePtr,
-                                   TransactionFuncT&& cont) override
+    virtual void AsyncContinuation(TransactionFlagsT flags, const WaitingStatePtrT& waitingStatePtr, TransactionFuncT&& cont) override
     {
         AsyncTransaction(flags, waitingStatePtr, std::move(cont));
     }
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index f188e55c..7459af80 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -470,7 +470,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
             // All slots ready?
             apply(
                 [this, &isReady] (Slot<Ts>& ... slots)
-								{
+                {
                     // Todo: combine return values instead
                     REACT_EXPAND_PACK(CheckSlot(slots, isReady));
                 },
@@ -554,8 +554,8 @@ class EventLinkNode : public EventStreamNode<E>
         this->UnregisterMe();
     }
 
-		void SetWeakSelfPtr(const std::weak_ptr<EventLinkNode>& self)
-				{	linkOutput_.parent = self; }
+    void SetWeakSelfPtr(const std::weak_ptr<EventLinkNode>& self)
+        { linkOutput_.parent = self; }
 
     virtual const char* GetNodeType() const override
         { return "EventLink"; }
@@ -564,10 +564,10 @@ class EventLinkNode : public EventStreamNode<E>
         { return 1; }
 
     virtual UpdateResult Update(TurnId turnId, int successorCount) override
-		{
-				this->SetPendingSuccessorCount(successorCount);
-				return UpdateResult::changed;
-		}
+    {
+        this->SetPendingSuccessorCount(successorCount);
+        return UpdateResult::changed;
+    }
 
     void SetEvents(EventLinkNode::EventStreamNode::StorageType&& events)
         { this->Events() = std::move(events); }
@@ -576,19 +576,19 @@ class EventLinkNode : public EventStreamNode<E>
     struct VirtualOutputNode : public ILinkOutputNode
     {
         VirtualOutputNode(const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<EventStreamNode<E>>& depIn) :
-						parent( ),
+            parent( ),
             srcGraphPtr( srcGraphPtrIn ),
             dep( depIn )
         {
-					nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-					srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
-				}
+            nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
+            srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
+        }
 
-				~VirtualOutputNode()
-				{
-						srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
-						srcGraphPtr->UnregisterNode(nodeId);
-				}
+        ~VirtualOutputNode()
+        {
+            srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
+            srcGraphPtr->UnregisterNode(nodeId);
+        }
 
         virtual const char* GetNodeType() const override
             { return "EventLinkOutput"; }
@@ -598,30 +598,30 @@ class EventLinkNode : public EventStreamNode<E>
 
         virtual UpdateResult Update(TurnId turnId, int successorCount) override
         {            
-						return UpdateResult::changed;
+            return UpdateResult::changed;
         }
 
         virtual void CollectOutput(LinkOutputMap& output) override
         {
-					if (auto p = parent.lock())
-					{
-						auto* rawPtr = p->GraphPtr().get();
-						output[rawPtr].push_back(
-							[storedParent = std::move(p), storedEvents = dep->Events()] () mutable
-							{
-								NodeId nodeId = storedParent->GetNodeId();
-								auto& graphPtr = storedParent->GraphPtr();
-
-								graphPtr->AddInput(nodeId,
-									[&storedParent, &storedEvents]
-									{
-										storedParent->SetEvents(std::move(storedEvents));
-									});
-							});
-					}
-				}
-
-				std::weak_ptr<EventLinkNode> parent;
+            if (auto p = parent.lock())
+            {
+                auto* rawPtr = p->GraphPtr().get();
+                output[rawPtr].push_back(
+                    [storedParent = std::move(p), storedEvents = dep->Events()] () mutable
+                    {
+                        NodeId nodeId = storedParent->GetNodeId();
+                        auto& graphPtr = storedParent->GraphPtr();
+
+                        graphPtr->AddInput(nodeId,
+                            [&storedParent, &storedEvents]
+                            {
+                                storedParent->SetEvents(std::move(storedEvents));
+                            });
+                    });
+            }
+        }
+
+        std::weak_ptr<EventLinkNode> parent;
 
         NodeId nodeId;
 
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index f8887d8b..d4f3968a 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -158,7 +158,7 @@ class SyncedEventObserverNode : public ObserverNode
     virtual UpdateResult Update(TurnId turnId, int successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
-        if (events_->Events().empty())
+        if (subject_->Events().empty())
             return UpdateResult::unchanged;
 
         apply([this] (const auto& ... syncs) { func_(EventRange<E>( this->subject_->Events() ), syncs->Value() ...); }, syncHolder_);
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index d084945d..cb66531d 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -319,8 +319,8 @@ class SignalLinkNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-		void SetWeakSelfPtr(const std::weak_ptr<SignalLinkNode>& self)
-				{	linkOutput_.parent = self; }
+    void SetWeakSelfPtr(const std::weak_ptr<SignalLinkNode>& self)
+        { linkOutput_.parent = self; }
 
     virtual const char* GetNodeType() const override
         { return "SignalLink"; }
@@ -343,19 +343,19 @@ class SignalLinkNode : public SignalNode<S>
     struct VirtualOutputNode : public ILinkOutputNode
     {
         VirtualOutputNode(const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<SignalNode<S>>& depIn) :
-						parent( ),
+            parent( ),
             srcGraphPtr( srcGraphPtrIn ),
             dep( depIn )
         {
-					nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-					srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
-				}
+            nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
+            srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
+        }
 
-				~VirtualOutputNode()
-				{
-						srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
-						srcGraphPtr->UnregisterNode(nodeId);
-				}
+        ~VirtualOutputNode()
+        {
+            srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
+            srcGraphPtr->UnregisterNode(nodeId);
+        }
 
         virtual const char* GetNodeType() const override
             { return "SignalLinkOutput"; }
@@ -370,25 +370,25 @@ class SignalLinkNode : public SignalNode<S>
 
         virtual void CollectOutput(LinkOutputMap& output) override
         {
-					if (auto p = parent.lock())
-					{
-						auto* rawPtr = p->GraphPtr().get();
-						output[rawPtr].push_back(
-							[storedParent = std::move(p), storedValue = dep->Value()]
-							{
-								NodeId nodeId = storedParent->GetNodeId();
-								auto& graphPtr = storedParent->GraphPtr();
-
-								graphPtr->AddInput(nodeId,
-									[&storedParent, &storedValue]
-									{
-										storedParent->SetValue(std::move(storedValue));
-									});
-							});
-					}
-				}
-
-				std::weak_ptr<SignalLinkNode> parent;
+            if (auto p = parent.lock())
+            {
+                auto* rawPtr = p->GraphPtr().get();
+                output[rawPtr].push_back(
+                    [storedParent = std::move(p), storedValue = dep->Value()]
+                    {
+                        NodeId nodeId = storedParent->GetNodeId();
+                        auto& graphPtr = storedParent->GraphPtr();
+
+                        graphPtr->AddInput(nodeId,
+                            [&storedParent, &storedValue]
+                            {
+                                storedParent->SetValue(std::move(storedValue));
+                            });
+                    });
+            }
+        }
+
+        std::weak_ptr<SignalLinkNode> parent;
 
         NodeId nodeId;
 

From 33cab90c56aa3168720ea432b1ad2a95aa5e9d81 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 12 Dec 2016 18:35:46 +0100
Subject: [PATCH 38/75] fixes

---
 include/react/Algorithm.h                  | 10 ++--
 include/react/detail/graph/PropagationST.h | 62 ++++++++--------------
 2 files changed, 27 insertions(+), 45 deletions(-)

diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index 9a033559..6a0037a2 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -79,7 +79,7 @@ auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
     using REACT_IMPL::PrivateNodeInterface;
     using REACT_IMPL::CtorTag;
 
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
+    const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
     return Event<S, unique>( CtorTag{ }, std::make_shared<MonitorNode<S>>(
         graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal)) );
@@ -197,8 +197,8 @@ auto Snapshot(const ReactiveGroupBase& group, const SignalBase<S>& signal, const
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Event<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
-        graphPtr, PrivateNodeInterface::NodePtr(signal), PrivateNodeInterface::NodePtr(evnt)) );
+    return Signal<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
 }
 
 template <typename S, typename E>
@@ -212,7 +212,7 @@ auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& evnt) -> Signal<S
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
-    return Event<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
+    return Signal<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
         graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
 }
 
@@ -231,7 +231,7 @@ auto Pulse(const ReactiveGroupBase& group, const SignalBase<S>& signal, const Ev
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
     return Event<S, unique>( CtorTag{ }, std::make_shared<PulseNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::NodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::NodePtr(graphPtr, evnt)) );
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
 }
 
 template <typename S, typename E>
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index 182cfcd0..4b8f2441 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -44,7 +44,7 @@ class TransactionQueue
     template <typename F>
     void Push(TransactionFlags flags, F&& transaction)
     {
-				transactions_.push(StoredTransaction{ flags, std::forward<F>(transaction) });
+        transactions_.push(StoredTransaction{ flags, std::forward<F>(transaction) });
 
         if (count_.fetch_add(1, std::memory_order_relaxed) == 0)
             tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(*this));
@@ -117,7 +117,7 @@ class ReactiveGraph
         NodeData(IReactiveNode* nodePtrIn, NodeCategory categoryIn) :
             nodePtr( nodePtrIn ),
             category(categoryIn)
-						{ }
+            { }
 
         NodeCategory category = NodeCategory::normal;
 
@@ -238,8 +238,8 @@ void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
             if (! scheduledNodes_.IsEmpty())
                 Propagate();
 
-						if (! scheduledLinkOutputs_.empty())
-								UpdateLinkNodes();
+            if (! scheduledLinkOutputs_.empty())
+                UpdateLinkNodes();
         }
     }
 }
@@ -303,12 +303,12 @@ void ReactiveGraph::Propagate()
                 continue;
             }
 
-						// Special handling for link output nodes. They have no successors and they don't have to be updated.
-						if (node.category == NodeCategory::linkoutput)
-						{
-							static_cast<ILinkOutputNode*>(node.nodePtr)->CollectOutput(scheduledLinkOutputs_);
-							continue;
-						}
+            // Special handling for link output nodes. They have no successors and they don't have to be updated.
+            if (node.category == NodeCategory::linkoutput)
+            {
+                static_cast<ILinkOutputNode*>(node.nodePtr)->CollectOutput(scheduledLinkOutputs_);
+                continue;
+            }
 
             int successorCount = node.successors.size();
 
@@ -324,35 +324,17 @@ void ReactiveGraph::Propagate()
 
 void ReactiveGraph::UpdateLinkNodes()
 {
-	for (auto& e : scheduledLinkOutputs_)
-	{
-		e.first->EnqueueTransaction(TransactionFlags::none,
-			[inputs = std::move(e.second)]
-			{
-				for (auto& callback : inputs)
-					callback();
-			});
-	}
-
-	scheduledLinkOutputs_.clear();
-
-	/*using ElementType = std::pair<ReactiveGraph*, IReactiveNode*>;
-
-	auto from = scheduledLinkOutputs_.begin();
-	auto to = scheduledLinkOutputs_.end();
-
-	for (auto it = from; it != to; ++it)
-	{
-		ReactiveGraph* graphPtr = it->first;
-		auto p = std::partition(it, to, [=] (ReactiveGraph* e) { return e == graphPtr });
-
-		for (auto it2 = p; it2 != to; ++it2)
-		{
-			graphPtr->EnqueueLinkTransaction();
-		}
-	}
-
-	scheduledLinkOutputs_.clear();*/
+    for (auto& e : scheduledLinkOutputs_)
+    {
+        e.first->EnqueueTransaction(TransactionFlags::none,
+            [inputs = std::move(e.second)]
+            {
+                for (auto& callback : inputs)
+                    callback();
+            });
+    }
+
+    scheduledLinkOutputs_.clear();
 }
 
 void ReactiveGraph::ScheduleSuccessors(NodeData& node)
@@ -364,7 +346,7 @@ void ReactiveGraph::ScheduleSuccessors(NodeData& node)
         if (!succ.queued)
         {
             succ.queued = true;
-						scheduledNodes_.Push(succId, succ.level);
+            scheduledNodes_.Push(succId, succ.level);
         }
     }
 }

From f5454397a9e82ac131738e36e47ae57a45704b86 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 12 Dec 2016 23:01:18 +0100
Subject: [PATCH 39/75] example + benchmark fixes, wip

---
 benchmarks/src/BenchmarkBase.h              | 15 +----
 benchmarks/src/BenchmarkGrid.h              | 60 +++++++++-----------
 benchmarks/src/Main.cpp                     | 17 +-----
 examples/src/BasicAlgorithms.cpp            | 10 ++--
 examples/src/BasicEvents.cpp                | 38 +------------
 examples/src/BasicObservers.cpp             |  2 +-
 examples/src/BasicSignals.cpp               | 50 +++--------------
 examples/src/BasicSynchronization.cpp       | 25 ++++++---
 include/react/Group.h                       | 62 ++-------------------
 include/react/detail/IReactiveGraph.h       |  2 +-
 include/react/detail/graph/AlgorithmNodes.h | 17 +++---
 include/react/detail/graph/EventNodes.h     | 22 ++++----
 include/react/detail/graph/ObserverNodes.h  |  6 +-
 include/react/detail/graph/PropagationST.h  |  8 +--
 include/react/detail/graph/SignalNodes.h    | 12 ++--
 15 files changed, 103 insertions(+), 243 deletions(-)

diff --git a/benchmarks/src/BenchmarkBase.h b/benchmarks/src/BenchmarkBase.h
index 4b65306a..528a8489 100644
--- a/benchmarks/src/BenchmarkBase.h
+++ b/benchmarks/src/BenchmarkBase.h
@@ -55,18 +55,6 @@ inline const std::string CurrentDateTime()
     return buf;
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// BenchmarkBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class BenchmarkBase
-{
-public:
-    typedef D Domain;
-
-    double        Run();
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// RunBenchmark
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -118,8 +106,7 @@ template
 <
     int RUN_COUNT,
     template <typename> class TBenchmark,
-    typename TParams,
-    typename ... Ds
+    typename TParams
 >
 void RunBenchmarkClass(const char* name, std::ostream& out, const TParams& params)
 {
diff --git a/benchmarks/src/BenchmarkGrid.h b/benchmarks/src/BenchmarkGrid.h
index d719afaa..29afe312 100644
--- a/benchmarks/src/BenchmarkGrid.h
+++ b/benchmarks/src/BenchmarkGrid.h
@@ -21,47 +21,42 @@ using namespace react;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// GridGraphGenerator
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename D,
-    typename TValue
->
+template <typename T>
 class GridGraphGenerator
 {
 public:
-    using MySignal = Signal<D,TValue>;
+    using SignalType = Signal<T, shared>;
 
-    using Func1T = std::function<TValue(TValue)>;
-    using Func2T = std::function<TValue(TValue,TValue)>;
+    using Func1T = std::function<T(T)>;
+    using Func2T = std::function<T(T, T)>;
 
-    using SignalVectT   = std::vector<MySignal>;
-    using WidthVectT    = std::vector<size_t>;
+    using SignalVectType = std::vector<SignalType>;
 
-    SignalVectT InputSignals;
-    SignalVectT OutputSignals;
+    SignalVectType inputSignals;
+    SignalVectType outputSignals;
 
-    Func1T  Function1;
-    Func2T  Function2;
+    Func1T  function1;
+    Func2T  function2;
 
-    WidthVectT  Widths;
+    std::vector<size_t>  widths;
 
     void Generate()
     {
-        assert(InputSignals.size() >= 1);
-        assert(Widths.size() >= 1);
+        assert(inputSignals.size() >= 1);
+        assert(widths.size() >= 1);
 
-        SignalVectT buf1 = InputSignals;
-        SignalVectT buf2;
+        SignalVectType buf1 = std::move(inputSignals);
+        SignalVectType buf2;
 
         SignalVectT* curBuf = &buf1;
         SignalVectT* nextBuf = &buf2;
 
-        size_t curWidth = InputSignals.size();
+        size_t curWidth = inputSignals.size();
 
         size_t nodeCount = 1;
         nodeCount += curWidth;
 
-        for (auto targetWidth : Widths)
+        for (auto targetWidth : widths)
         {
             while (curWidth != targetWidth)
             {
@@ -110,8 +105,8 @@ class GridGraphGenerator
 
         //printf ("NODE COUNT %d\n", nodeCount);
 
-        OutputSignals.clear();
-        OutputSignals.insert(OutputSignals.begin(), curBuf->begin(), curBuf->end());
+        outputSignals.clear();
+        outputSignals.insert(outputSignals.begin(), curBuf->begin(), curBuf->end());
     }
 };
 
@@ -135,22 +130,21 @@ struct BenchmarkParams_Grid
     const int K;
 };
 
-template <typename D>
-struct Benchmark_Grid : public BenchmarkBase<D>
+struct Benchmark_Grid
 {
-    double Run(const BenchmarkParams_Grid& params)
+    double Run(const BenchmarkParams_Grid& params, const ReactiveGroupBase& group)
     {
-        auto in = MakeVar<D>(1);
+        VarSignal<int, shared> in{ group, 1 };
 
-        GridGraphGenerator<D,int> generator;
+        GridGraphGenerator<int> generator;
 
-        generator.InputSignals.push_back(in);
+        generator.inputSignals.push_back(in);
 
-        generator.Widths.push_back(params.N);
-        generator.Widths.push_back(1);
+        generator.widths.push_back(params.N);
+        generator.widths.push_back(1);
 
-        generator.Function1 = [] (int a) { return a; };
-        generator.Function2 = [] (int a, int b) { return a + b; };
+        generator.function1 = [] (int a) { return a; };
+        generator.function2 = [] (int a, int b) { return a + b; };
 
         generator.Generate();
 
diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index 93a79d78..cbf5aaca 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -17,31 +17,16 @@
 #include "BenchmarkSequence.h"
 #include "BenchmarkLifeSim.h"
 
-#include "react/Domain.h"
+#include "react/Group.h"
 #include "react/Signal.h"
 #include "react/Algorithm.h"
 #include "react/common/Util.h"
-#include "react/logging/EventLog.h"
-
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/SubtreeEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
 using namespace react;
 
-REACTIVE_DOMAIN(ToposortSTDomain, sequential, ToposortEngine)
-REACTIVE_DOMAIN(ToposortDomain, parallel, ToposortEngine)
-REACTIVE_DOMAIN(PulsecountDomain, parallel, PulsecountEngine)
-REACTIVE_DOMAIN(SubtreeDomain, parallel, SubtreeEngine)
-
-REACTIVE_DOMAIN(ToposortSTDomainConc, sequential_concurrent, ToposortEngine)
-REACTIVE_DOMAIN(ToposortDomainConc, parallel_concurrent, ToposortEngine)
-REACTIVE_DOMAIN(PulsecountDomainConc, parallel_concurrent, PulsecountEngine)
-REACTIVE_DOMAIN(SubtreeDomainConc, parallel_concurrent, SubtreeEngine)
-
 void runBenchmarkGrid(std::ostream& out)
 {
     RUN_BENCHMARK(out, 5, Benchmark_Grid, BenchmarkParams_Grid(20, 10000),
diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index 1e84305d..a11dbdb9 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -66,8 +66,8 @@ namespace example2
 
     struct Employee
     {
-        VarSignal<string>   name    { string( "Bob" ), group };
-        VarSignal<int>      salary  { 3000, group };
+        VarSignal<string>   name    { group, string( "Bob" ) };
+        VarSignal<int>      salary  { group, 3000 };
     };
 
     void Run()
@@ -213,8 +213,8 @@ namespace example5
     public:
         EventSource<int> update{ group };
 
-        VarSignal<int> delta{ 1, group };
-        VarSignal<int> start{ 0, group };
+        VarSignal<int> delta{ group, 1 };
+        VarSignal<int> start{ group, 0 };
 
         Signal<int> count{ Iterate<int>(start.Value(), DoCounterLoop, update, delta, start) };
     };
@@ -276,7 +276,7 @@ namespace example6
     public:
         EventSource<int> input{ group };
 
-        VarSignal<int> threshold{ 42, group };
+        VarSignal<int> threshold{ group, 42 };
 
         Signal<vector<int>> allSamples{ Iterate<vector<int>>(vector<int>{ }, DoIterateAllSamples, input) };
 
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index 0f4f3f06..b9a7cfbd 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -237,46 +237,12 @@ namespace example5
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    using namespace std;
-    using namespace react;
-
-    ReactiveGroup<> group;
-
-    auto ev1 = EventSource<int>( group );
-    auto ev2 = EventSource<int>( group );
-
-    auto slot1 = EventSlot<int>( ev1, group );
-    auto slot2 = EventSlot<int>( ev1, group );
-
-    Observer<> obs1(
-        [] (EventRange<int> in)
-        {
-            for (int e : in)
-                cout << e << endl;
-        }, slot1);
-
-    Observer<> obs2(
-        [] (EventRange<int> in)
-        {
-            for (int e : in)
-                cout << e << endl;
-        }, slot2);
-
-    ev1 << 10 << 20 << 30;
-    ev2 << 11 << 22 << 33;
-
-    slot1.Set(ev2);
-    slot2.Set(ev2);
-
-    ev1 << 10 << 20 << 30;
-    ev2 << 11 << 22 << 33;
-
-    /*example1::v1::Run();
+    example1::v1::Run();
     example1::v2::Run();
     example2::Run();
     example3::Run();
     example4::Run();
-    example5::Run();*/
+    example5::Run();
 
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index 0a282528..c81cb372 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -22,7 +22,7 @@ namespace example1
 
     ReactiveGroup<> group;
 
-    VarSignal<int> x( 1, group );
+    VarSignal<int> x( group, 1 );
 
     void Run()
     {
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 44369987..fc52eb68 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -32,8 +32,8 @@ namespace example1
     ReactiveGroup<> group;
     
     // The two words
-    VarSignal<string> firstWord( string("Change"), group );
-    VarSignal<string> secondWord( string("me!"), group );
+    VarSignal<string> firstWord( group, string("Change") );
+    VarSignal<string> secondWord( group, string("me!") );
 
     // A signal that concatenates both words
     Signal<string> bothWords(ConcatFunc, firstWord, secondWord);
@@ -66,7 +66,7 @@ namespace example2
 
     ReactiveGroup<> group;
 
-    VarSignal<int> x( 1, group );
+    VarSignal<int> x( group, 1 );
 
     Signal<int> xAbs( [] (int v) { return abs(v); }, x);
 
@@ -100,8 +100,8 @@ namespace example3
 
     ReactiveGroup<> group;
 
-    VarSignal<int> a( 1, group );
-    VarSignal<int> b( 1, group );
+    VarSignal<int> a( group, 1 );
+    VarSignal<int> b( group, 1 );
 
     Signal<int> x( sumFunc, a, b );
     Signal<int> y( sumFunc, a, b );
@@ -186,8 +186,8 @@ namespace example5
     }
 
     // Input operands
-    VarSignal<int> a( 1, group );
-    VarSignal<int> b( 2, group );
+    VarSignal<int> a( group, 1 );
+    VarSignal<int> b( group, 2 );
 
     // The expression vector
     Signal<ExprVectType> expressions(
@@ -218,43 +218,11 @@ namespace example5
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    using namespace std;
-    using namespace react;
-
-    ReactiveGroup<> group;
-
-    auto sig1 = VarSignal<int>( 10, group );
-    auto sig2 = VarSignal<int>( 22, group );
-
-    auto slot1 = SignalSlot<int>( sig1, group );
-    auto slot2 = SignalSlot<int>( sig1, group );
-
-    printf("%d\n", slot1.Value());
-    printf("%d\n", slot2.Value());
-
-    slot1.Set(sig2);
-    slot2.Set(sig2);
-
-    printf("%d\n", slot1.Value());
-    printf("%d\n", slot2.Value());
-
-    group.DoTransaction([&]
-    {
-        slot1.Set(sig2);
-        slot2.Set(sig2);
-    });
-
-    group.EnqueueTransaction([&]
-    {
-        slot1.Set(sig2);
-        slot2.Set(sig2);
-    });
-
-    /*example1::Run();
+    example1::Run();
     example2::Run();
     example3::Run();
     example4::Run();
-    example5::Run();*/
+    example5::Run();
 
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index 4a7f6529..a79f87ce 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -21,25 +21,36 @@ namespace example1
     using namespace react;
     using namespace std;
 
-    REACTIVE_DOMAIN(D, sequential_concurrent)
+    ReactiveGroup<> group;
 
     class Sensor
     {
     public:
-        USING_REACTIVE_DOMAIN(D)
+        Sensor(const Sensor&) = default;
+        Sensor& operator=(const Sensor&) = default;
+        Sensor(Sensor&&) = default;
+        Sensor& operator=(Sensor&&) = default;
 
-        EventSourceT<int>   Samples     = MakeEventSource<D,int>();
+        explicit Sensor(const ReactiveGroup<>& group) :
+            Samples( group )
+            { }
+
+        EventSource<int>    Samples;
     };
 
     void Run()
     {
         cout << "Example 1 - Asynchronous transactions" << endl;
 
-        Sensor mySensor;
+        Sensor mySensor( group );
 
-        Observe(mySensor.Samples, [] (int v) {
-            cout << v << endl;
-        });
+        Observer<> obs(
+            [&] (EventRange<> in)
+            {
+                for (auto t : in)
+                    cout << v << endl;
+            },
+            mySensor.Samples);
 
         TransactionStatus status;
 
diff --git a/include/react/Group.h b/include/react/Group.h
index fc5e49f1..ca2c02f0 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -28,8 +28,6 @@ struct CtorTag { };
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
-
-
 #if 0
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -84,54 +82,6 @@ class TransactionStatus
     friend void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& func);
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////
-/// AsyncTransaction
-///////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D, typename F>
-void AsyncTransaction(F&& func)
-{
-    static_assert(D::is_concurrent,
-        "AsyncTransaction: Domain does not support concurrent input.");
-
-    using REACT_IMPL::DomainSpecificInputManager;
-    DomainSpecificInputManager<D>::Instance()
-        .AsyncTransaction(0, nullptr, std::forward<F>(func));
-}
-
-template <typename D, typename F>
-void AsyncTransaction(TransactionFlags flags, F&& func)
-{
-    static_assert(D::is_concurrent,
-        "AsyncTransaction: Domain does not support concurrent input.");
-
-    using REACT_IMPL::DomainSpecificInputManager;
-    DomainSpecificInputManager<D>::Instance()
-        .AsyncTransaction(flags, nullptr, std::forward<F>(func));
-}
-
-template <typename D, typename F>
-void AsyncTransaction(TransactionStatus& status, F&& func)
-{
-    static_assert(D::is_concurrent,
-        "AsyncTransaction: Domain does not support concurrent input.");
-
-    using REACT_IMPL::DomainSpecificInputManager;
-
-    DomainSpecificInputManager<D>::Instance()
-        .AsyncTransaction(0, status.statePtr_, std::forward<F>(func));
-}
-
-template <typename D, typename F>
-void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& func)
-{
-    static_assert(D::is_concurrent,
-        "AsyncTransaction: Domain does not support concurrent input.");
-
-    using REACT_IMPL::DomainSpecificInputManager;
-    DomainSpecificInputManager<D>::Instance()
-        .AsyncTransaction(flags, status.statePtr_, std::forward<F>(func));
-}
-
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -146,12 +96,6 @@ class ReactiveGroupBase
         graphPtr_( std::make_shared<GraphType>() )
         {  }
 
-    ReactiveGroupBase(const ReactiveGroupBase&) = default;
-    ReactiveGroupBase& operator=(const ReactiveGroupBase&) = default;
-
-    ReactiveGroupBase(ReactiveGroupBase&& other) = default;
-    ReactiveGroupBase& operator=(ReactiveGroupBase&& other) = default;
-
     ~ReactiveGroupBase() = default;
 
     template <typename F>
@@ -167,6 +111,12 @@ class ReactiveGroupBase
         { graphPtr_->EnqueueTransaction(flags, std::forward<F>(func)); }
 
 protected:
+    ReactiveGroupBase(const ReactiveGroupBase&) = default;
+    ReactiveGroupBase& operator=(const ReactiveGroupBase&) = default;
+
+    ReactiveGroupBase(ReactiveGroupBase&& other) = default;
+    ReactiveGroupBase& operator=(ReactiveGroupBase&& other) = default;
+
     auto GraphPtr() -> std::shared_ptr<GraphType>&
         { return graphPtr_; }
 
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/IReactiveGraph.h
index 2ac8f291..85f3d253 100644
--- a/include/react/detail/IReactiveGraph.h
+++ b/include/react/detail/IReactiveGraph.h
@@ -59,7 +59,7 @@ struct IReactiveNode
 
     virtual const char* GetNodeType() const = 0;
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) = 0;
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) = 0;
 
     virtual int GetDependencyCount() const = 0;
 };
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 62ff5c9a..274581fd 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -101,7 +101,7 @@ class IterateNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         S newValue = func_(EventRange<E>( events_->Events() ), this->Value());
 
@@ -153,7 +153,7 @@ class IterateByRefNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         func_(EventRange<E>( events_->Events() ), this->Value());
 
@@ -201,7 +201,7 @@ class SyncedIterateNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (events_->Events().empty())
@@ -267,7 +267,7 @@ class SyncedIterateByRefNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (events_->Events().empty())
@@ -281,7 +281,6 @@ class SyncedIterateByRefNode : public SignalNode<S>
             syncHolder_);
 
         events_->DecrementPendingSuccessorCount();
-        this->SetPendingSuccessorCount(successorCount);
 
         return UpdateResult::changed;
     }
@@ -325,7 +324,7 @@ class HoldNode : public SignalNode<S>
     virtual const char* GetNodeType() const override
         { return "HoldNode"; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         bool changed = false;
 
@@ -379,7 +378,7 @@ class SnapshotNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         bool changed = false;
         
@@ -434,7 +433,7 @@ class MonitorNode : public EventStreamNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         this->Events().push_back(target_->Value());
 
@@ -477,7 +476,7 @@ class PulseNode : public EventStreamNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         for (size_t i=0; i<trigger_->Events().size(); i++)
             this->Events().push_back(target_->Value());
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 7459af80..374038fb 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -98,7 +98,7 @@ class EventStreamNode : public NodeBase
         { return events_; }
 
 
-    void SetPendingSuccessorCount(int count)
+    void SetPendingSuccessorCount(size_t count)
     {
         if (count == 0)
         {
@@ -127,7 +127,7 @@ class EventStreamNode : public NodeBase
 private:
     StorageType events_;
     
-    std::atomic<int> pendingSuccessorCount_ = 0;
+    std::atomic<size_t> pendingSuccessorCount_ = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -150,7 +150,7 @@ class EventSourceNode : public EventStreamNode<T>
     virtual int GetDependencyCount() const override
         { return 0; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         if (! this->Events().empty())
         {
@@ -189,7 +189,7 @@ class EventMergeNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
@@ -254,7 +254,7 @@ class EventSlotNode : public EventStreamNode<E>
     virtual int GetDependencyCount() const override
         { return 2; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         this->Events().insert(this->Events().end(), slotInput_.dep->Events().begin(), slotInput_.dep->Events().end());
 
@@ -291,7 +291,7 @@ class EventSlotNode : public EventStreamNode<E>
         virtual int GetDependencyCount() const override
             { return 0; }
 
-        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
         {
             if (dep != newDep)
             {
@@ -342,7 +342,7 @@ class EventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         func_(EventRange<TIn>( dep_->Events() ), std::back_inserter(this->Events()));
 
@@ -397,7 +397,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (dep_->Events().empty())
@@ -458,7 +458,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Move events into buffers.
         apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
@@ -563,7 +563,7 @@ class EventLinkNode : public EventStreamNode<E>
     virtual int GetDependencyCount() const override
         { return 1; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         this->SetPendingSuccessorCount(successorCount);
         return UpdateResult::changed;
@@ -596,7 +596,7 @@ class EventLinkNode : public EventStreamNode<E>
         virtual int GetDependencyCount() const override
             { return 1; }
 
-        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
         {            
             return UpdateResult::changed;
         }
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index d4f3968a..d383d341 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -69,7 +69,7 @@ class SignalObserverNode : public ObserverNode
     virtual int GetDependencyCount() const override
         { return sizeof...(TDeps); }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         apply([this] (const auto& ... deps) { this->func_(deps->Value() ...); }, depHolder_);
         return UpdateResult::unchanged;
@@ -110,7 +110,7 @@ class EventObserverNode : public ObserverNode
     virtual int GetDependencyCount() const override
         { return 1; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         func_(EventRange<E>( subject_->Events() ));
         subject_->DecrementPendingSuccessorCount();
@@ -155,7 +155,7 @@ class SyncedEventObserverNode : public ObserverNode
     virtual int GetDependencyCount() const override
         { return 1 + sizeof...(TSyncs); }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (subject_->Events().empty())
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index 4b8f2441..dbce7777 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -227,7 +227,7 @@ void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
     }
     else
     {
-        int successorCount = node.successors.size();
+        size_t successorCount = node.successors.size();
 
         // Update the node. This applies the input buffer to the node value and checks if it changed.
         if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
@@ -258,7 +258,7 @@ void ReactiveGraph::DoTransaction(F&& transactionCallback)
         auto& node = nodeData_[nodeId];
         auto* nodePtr = node.nodePtr;
 
-        int successorCount = node.successors.size();
+        size_t successorCount = node.successors.size();
 
         if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
         {
@@ -310,9 +310,9 @@ void ReactiveGraph::Propagate()
                 continue;
             }
 
-            int successorCount = node.successors.size();
+            size_t successorCount = node.successors.size();
 
-            if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
+            if (nodePtr->Update(0u, successorCount) == UpdateResult::changed)
             {
                 ScheduleSuccessors(node);
             }
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index cb66531d..4dbd8574 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -87,7 +87,7 @@ class VarSignalNode : public SignalNode<S>
     virtual int GetDependencyCount() const override
         { return 0; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         if (isInputAdded_)
         {
@@ -182,7 +182,7 @@ class SignalFuncNode : public SignalNode<S>
     virtual int GetDependencyCount() const override
         { return sizeof...(TDeps); }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {   
         bool changed = false;
 
@@ -239,7 +239,7 @@ class SignalSlotNode : public SignalNode<S>
     virtual int GetDependencyCount() const override
         { return 2; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         if (! (this->Value() == slotInput_.dep->Value()))
         {
@@ -272,7 +272,7 @@ class SignalSlotNode : public SignalNode<S>
         virtual int GetDependencyCount() const override
             { return 0; }
 
-        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
         {
             if (dep != newDep)
             {
@@ -328,7 +328,7 @@ class SignalLinkNode : public SignalNode<S>
     virtual int GetDependencyCount() const override
         { return 1; }
 
-    virtual UpdateResult Update(TurnId turnId, int successorCount) override
+    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         return UpdateResult::changed;
     }
@@ -363,7 +363,7 @@ class SignalLinkNode : public SignalNode<S>
         virtual int GetDependencyCount() const override
             { return 1; }
 
-        virtual UpdateResult Update(TurnId turnId, int successorCount) override
+        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
         {   
             return UpdateResult::changed;
         }

From 933016dce85c34ff712529bf2cac94a180e08341 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Fri, 16 Dec 2016 18:04:21 +0100
Subject: [PATCH 40/75] wip stuff

---
 benchmarks/src/BenchmarkBase.h             |  13 +-
 benchmarks/src/BenchmarkFanout.h           |   7 +-
 benchmarks/src/BenchmarkGrid.h             |  33 ++--
 benchmarks/src/BenchmarkLifeSim.h          |  10 +-
 benchmarks/src/BenchmarkRandom.h           |   9 +-
 benchmarks/src/BenchmarkSequence.h         |   7 +-
 benchmarks/src/Main.cpp                    |  52 +++---
 examples/src/Main.cpp                      | 191 ++++++++++++++++++++-
 include/react/Signal.h                     |  41 +++--
 include/react/detail/graph/PropagationST.h |   2 +-
 10 files changed, 269 insertions(+), 96 deletions(-)

diff --git a/benchmarks/src/BenchmarkBase.h b/benchmarks/src/BenchmarkBase.h
index 528a8489..7df36bbe 100644
--- a/benchmarks/src/BenchmarkBase.h
+++ b/benchmarks/src/BenchmarkBase.h
@@ -66,9 +66,6 @@ template
 >
 void RunBenchmark(std::ostream& logfile, TBenchmark b, const TParams& params)
 {
-    std::cout   << "Engine: " << typeid(typename TBenchmark::Domain::Policy::Engine).name() << std::endl << std::endl;
-    logfile     << "Engine: " << typeid(typename TBenchmark::Domain::Policy::Engine).name() << std::endl << std::endl;
-
     double sum = 0;
     double min = DBL_MAX;
     double max = DBL_MIN;
@@ -77,7 +74,7 @@ void RunBenchmark(std::ostream& logfile, TBenchmark b, const TParams& params)
     {
         double r = b.Run(params);
         std::cout    << "\tRun " << i << ": " <<  r << std::endl;
-        logfile        << "\tRun " << i << ": " <<  r << std::endl;
+        logfile       << "\tRun " << i << ": " <<  r << std::endl;
         
         sum += r;
 
@@ -105,7 +102,7 @@ void RunBenchmark(std::ostream& logfile, TBenchmark b, const TParams& params)
 template
 <
     int RUN_COUNT,
-    template <typename> class TBenchmark,
+    typename TBenchmark,
     typename TParams
 >
 void RunBenchmarkClass(const char* name, std::ostream& out, const TParams& params)
@@ -118,8 +115,8 @@ void RunBenchmarkClass(const char* name, std::ostream& out, const TParams& param
     params.Print(out);
     out    << ") =====" << std::endl << std::endl;
 
-    REACT_EXPAND_PACK(RunBenchmark<RUN_COUNT>(out, TBenchmark<Ds>(), params));
+    RunBenchmark<RUN_COUNT>(out, TBenchmark(), params);
 }
 
-#define RUN_BENCHMARK(out, runCount, benchmarkClass, params, ...) \
-    RunBenchmarkClass<runCount, benchmarkClass, decltype(params), __VA_ARGS__>(#benchmarkClass, out, params)
+#define RUN_BENCHMARK(out, runCount, benchmarkClass, params) \
+    RunBenchmarkClass<runCount, benchmarkClass, decltype(params)>(#benchmarkClass, out, params)
diff --git a/benchmarks/src/BenchmarkFanout.h b/benchmarks/src/BenchmarkFanout.h
index 6feaf567..672b5f7c 100644
--- a/benchmarks/src/BenchmarkFanout.h
+++ b/benchmarks/src/BenchmarkFanout.h
@@ -16,7 +16,7 @@
 #include "BenchmarkBase.h"
 
 #include "react/Signal.h"
-
+/*
 using namespace react;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -42,8 +42,7 @@ struct BenchmarkParams_Fanout
     const int Delay;
 };
 
-template <typename D>
-struct Benchmark_Fanout : public BenchmarkBase<D>
+struct Benchmark_Fanout
 {
     double Run(const BenchmarkParams_Fanout& params)
     {
@@ -83,4 +82,6 @@ struct Benchmark_Fanout : public BenchmarkBase<D>
     }
 };
 
+*/
+
 #endif // CPP_REACT_BENCHMARK_FANOUT_H
\ No newline at end of file
diff --git a/benchmarks/src/BenchmarkGrid.h b/benchmarks/src/BenchmarkGrid.h
index 29afe312..6b691cc3 100644
--- a/benchmarks/src/BenchmarkGrid.h
+++ b/benchmarks/src/BenchmarkGrid.h
@@ -40,7 +40,7 @@ class GridGraphGenerator
 
     std::vector<size_t>  widths;
 
-    void Generate()
+    void Generate(const ReactiveGroupBase& group)
     {
         assert(inputSignals.size() >= 1);
         assert(widths.size() >= 1);
@@ -48,8 +48,8 @@ class GridGraphGenerator
         SignalVectType buf1 = std::move(inputSignals);
         SignalVectType buf2;
 
-        SignalVectT* curBuf = &buf1;
-        SignalVectT* nextBuf = &buf2;
+        SignalVectType* curBuf = &buf1;
+        SignalVectType* nextBuf = &buf2;
 
         size_t curWidth = inputSignals.size();
 
@@ -70,36 +70,36 @@ class GridGraphGenerator
 
                 if (shouldGrow)
                 {
-                    auto s = (*l) ->* Function1;
-                    nextBuf->push_back(s);
+										auto s = SignalType{ group, function1, *l };
+                    nextBuf->push_back(std::move(s));
                 }
 
                 while (r != curBuf->end())
                 {
-                    auto s = (*l,*r) ->* Function2;
-                    nextBuf->push_back(s);
-                    nodeCount++;
+										auto s = SignalType{ group, function2, *l, *r };
+                    nextBuf->push_back(std::move(s));
+                    ++nodeCount;
                     ++l; ++r;
                 }
 
                 if (shouldGrow)
                 {
-                    auto s = (*l) ->* Function1;
-                    nextBuf->push_back(s);
-                    nodeCount++;
+                    auto s = SignalType{ group, function1, *l };
+                    nextBuf->push_back(std::move(s));
+                    ++nodeCount;
                 }
 
                 curBuf->clear();
 
                 // Swap buffer pointers
-                SignalVectT* t = curBuf;
+                SignalVectType* t = curBuf;
                 curBuf = nextBuf;
                 nextBuf = t;
 
                 if (shouldGrow)
-                    curWidth++;
+                    ++curWidth;
                 else
-                    curWidth--;
+                    --curWidth;
             }
         }
 
@@ -135,10 +135,11 @@ struct Benchmark_Grid
     double Run(const BenchmarkParams_Grid& params, const ReactiveGroupBase& group)
     {
         VarSignal<int, shared> in{ group, 1 };
+				Signal<int, shared> in2 = in;
 
         GridGraphGenerator<int> generator;
 
-        generator.inputSignals.push_back(in);
+        generator.inputSignals.push_back(in2);
 
         generator.widths.push_back(params.N);
         generator.widths.push_back(1);
@@ -146,7 +147,7 @@ struct Benchmark_Grid
         generator.function1 = [] (int a) { return a; };
         generator.function2 = [] (int a, int b) { return a + b; };
 
-        generator.Generate();
+        generator.Generate(group);
 
         auto t0 = tbb::tick_count::now();
         for (int i=0; i<params.K; i++)
diff --git a/benchmarks/src/BenchmarkLifeSim.h b/benchmarks/src/BenchmarkLifeSim.h
index 39acc2df..6521f2d4 100644
--- a/benchmarks/src/BenchmarkLifeSim.h
+++ b/benchmarks/src/BenchmarkLifeSim.h
@@ -5,7 +5,7 @@
 //          http://www.boost.org/LICENSE_1_0.txt)
 
 #pragma once
-
+/*
 #include <iostream>
 #include <fstream>
 #include <memory>
@@ -318,8 +318,10 @@ struct Benchmark_LifeSim : public BenchmarkBase<D>
         logfile.open("log.txt");
 
         D::Log().Write(logfile);
-        logfile.close()*/;
+        logfile.close()*//*;
 
-        return d;
+        //return d;
     }
-};
\ No newline at end of file
+};
+
+*/
\ No newline at end of file
diff --git a/benchmarks/src/BenchmarkRandom.h b/benchmarks/src/BenchmarkRandom.h
index bf3ba9d1..e3ffe9ef 100644
--- a/benchmarks/src/BenchmarkRandom.h
+++ b/benchmarks/src/BenchmarkRandom.h
@@ -14,11 +14,11 @@
 #include "BenchmarkBase.h"
 #include "react/common/Types.h"
 
-#include "react/Domain.h"
+#include "react/Group.h"
 #include "react/Signal.h"
 
 using namespace react;
-
+/*
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// DiamondGraphGenerator
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -215,8 +215,7 @@ struct BenchmarkParams_Random
     const int SlowSeed;
 };
 
-template <typename D>
-struct Benchmark_Random : public BenchmarkBase<D>
+struct Benchmark_Random
 {
     double Run(const BenchmarkParams_Random& params)
     {
@@ -321,4 +320,4 @@ struct Benchmark_Random : public BenchmarkBase<D>
 
         return d;
     }
-};
\ No newline at end of file
+};*/
\ No newline at end of file
diff --git a/benchmarks/src/BenchmarkSequence.h b/benchmarks/src/BenchmarkSequence.h
index 5e96d3c7..bf87bc41 100644
--- a/benchmarks/src/BenchmarkSequence.h
+++ b/benchmarks/src/BenchmarkSequence.h
@@ -14,6 +14,8 @@
 
 #include "react/Signal.h"
 
+/*
+
 using namespace react;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -39,8 +41,7 @@ struct BenchmarkParams_Sequence
     const int Delay;
 };
 
-template <typename D>
-struct Benchmark_Sequence : public BenchmarkBase<D>
+struct Benchmark_Sequence
 {
     double Run(const BenchmarkParams_Sequence& params)
     {
@@ -76,4 +77,4 @@ struct Benchmark_Sequence : public BenchmarkBase<D>
 
         return d;
     }
-};
\ No newline at end of file
+};*/
\ No newline at end of file
diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index cbf5aaca..2af96fdd 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -27,7 +27,7 @@ namespace {
 
 using namespace react;
 
-void runBenchmarkGrid(std::ostream& out)
+/*void runBenchmarkGrid(std::ostream& out)
 {
     RUN_BENCHMARK(out, 5, Benchmark_Grid, BenchmarkParams_Grid(20, 10000),
         ToposortSTDomain, ToposortDomain, PulsecountDomain);
@@ -40,9 +40,9 @@ void runBenchmarkGrid(std::ostream& out)
 
     RUN_BENCHMARK(out, 5, Benchmark_Grid, BenchmarkParams_Grid(50, 10000),
         ToposortSTDomain, ToposortDomain, PulsecountDomain);
-}
+}*/
 
-void runBenchmarkRandom(std::ostream& out)
+/*void runBenchmarkRandom(std::ostream& out)
 {
     const auto w = 20;
     const auto h = 11;
@@ -67,7 +67,7 @@ void runBenchmarkRandom(std::ostream& out)
         seed1 *= 2;
         seed2 *= 2;
     }
-}
+}*/
 
 void runBenchmarkFanout(std::ostream& out)
 {
@@ -80,14 +80,14 @@ void runBenchmarkFanout(std::ostream& out)
     //RUN_BENCHMARK(out, 5, Benchmark_Fanout, BenchmarkParams_Fanout(1000, 10000, 0),
     //    ToposortSTDomain, ToposortDomain, ELMDomain, PulsecountDomain, SourceSetDomain);
 
-    RUN_BENCHMARK(out, 3, Benchmark_Fanout, BenchmarkParams_Fanout(10, 10, 10),
+ /*   RUN_BENCHMARK(out, 3, Benchmark_Fanout, BenchmarkParams_Fanout(10, 10, 10),
         ToposortSTDomain, ToposortDomain, PulsecountDomain);
 
     RUN_BENCHMARK(out, 3, Benchmark_Fanout, BenchmarkParams_Fanout(100, 10, 10),
         ToposortSTDomain, ToposortDomain, PulsecountDomain);
 
     RUN_BENCHMARK(out, 3, Benchmark_Fanout, BenchmarkParams_Fanout(1000, 10, 10),
-        ToposortSTDomain, ToposortDomain, PulsecountDomain);
+        ToposortSTDomain, ToposortDomain, PulsecountDomain);*/
 }
 
 void runBenchmarkSequence(std::ostream& out)
@@ -101,14 +101,14 @@ void runBenchmarkSequence(std::ostream& out)
     //RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(1000, 10000, 0),
     //    ToposortSTDomain, ToposortDomain, ELMDomain, PulsecountDomain, SourceSetDomain);
 
-    RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(10, 10, 10),
-        ToposortSTDomain, ToposortDomain, PulsecountDomain);
+    //RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(10, 10, 10),
+    //    ToposortSTDomain, ToposortDomain, PulsecountDomain);
 
-    RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(100, 10, 10),
-        ToposortSTDomain, ToposortDomain, PulsecountDomain);
+    //RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(100, 10, 10),
+    //    ToposortSTDomain, ToposortDomain, PulsecountDomain);
 
-    RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(1000, 10, 10),
-        ToposortSTDomain, ToposortDomain, PulsecountDomain);
+    //RUN_BENCHMARK(out, 3, Benchmark_Sequence, BenchmarkParams_Sequence(1000, 10, 10),
+    //    ToposortSTDomain, ToposortDomain, PulsecountDomain);
 }
 
 void runBenchmarkLifeSim(std::ostream& out)
@@ -119,8 +119,8 @@ void runBenchmarkLifeSim(std::ostream& out)
     //RUN_BENCHMARK(std::cout, 1, Benchmark_LifeSim, BenchmarkParams_LifeSim(250, 30, 10000),
     //    SourceSetDomain, PulsecountDomain);
 
-    RUN_BENCHMARK(out, 1, Benchmark_LifeSim, BenchmarkParams_LifeSim(100, 15, 10000),
-        ToposortSTDomainConc, ToposortDomainConc, PulsecountDomainConc);
+    //RUN_BENCHMARK(out, 1, Benchmark_LifeSim, BenchmarkParams_LifeSim(100, 15, 10000),
+    //    ToposortSTDomainConc, ToposortDomainConc, PulsecountDomainConc);
 
     //RUN_BENCHMARK(out, 3, Benchmark_LifeSim, BenchmarkParams_LifeSim(100, 50, 100),
     //    PulsecountDomain, PulsecountDomain);
@@ -130,8 +130,8 @@ void runBenchmarks()
 {
     std::ofstream logfile;
 
-    std::string path = "Benchmark Results/" + CurrentDateTime() + ".txt";
-    logfile.open(path.c_str());
+    //std::string path = "Benchmark Results/" + CurrentDateTime() + ".txt";
+    //logfile.open(path.c_str());
 
     // === GRID
     //runBenchmarkGrid(logfile);
@@ -148,14 +148,14 @@ void runBenchmarks()
     //runBenchmarkSequence(logfile);
 
     // === LIFESIM
-    runBenchmarkLifeSim(logfile);
+    //runBenchmarkLifeSim(logfile);
 
     logfile.close();
 }
 
 void debugBenchmarks()
 {
-    using TestDomain = PulsecountDomain;
+    //using TestDomain = PulsecountDomain;
 
     //RUN_BENCHMARK(std::cout, 1, Benchmark_Grid, BenchmarkParams_Grid(30, 1),
     //    TestDomain);
@@ -172,8 +172,8 @@ void debugBenchmarks()
     //RUN_BENCHMARK(std::cout, 1, Benchmark_Random, BenchmarkParams_Random(10, 25, 10, 0, 10, 25, 25, false),
     //    ToposortDomain);
 
-    RUN_BENCHMARK(std::cout, 1, Benchmark_Random, BenchmarkParams_Random(40, 11, 2, 0, 1, 40, 40, false, 41556, 21624),
-        TestDomain);
+    //RUN_BENCHMARK(std::cout, 1, Benchmark_Random, BenchmarkParams_Random(40, 11, 2, 0, 1, 40, 40, false, 41556, 21624),
+    //    TestDomain);
 
     //const auto w = 10;
     //const auto h = 11;
@@ -194,21 +194,11 @@ void debugBenchmarks()
     //RunBenchmark<1>(Benchmark2<BTokenDomain>());
     //RunBenchmark<1>(Benchmark2<SourceSetDomain>());
     //RunBenchmark<3>(Benchmark2<ToposortDomain>());
-
-#ifdef REACT_ENABLE_LOGGING
-    std::ofstream logfile;
-    logfile.open("log.txt");
-
-    TestDomain::Log().Write(logfile);
-    logfile.close();
-#endif
 }
 
 void profileBenchmark()
 {
-    RUN_BENCHMARK(std::cout, 3, Benchmark_Grid, BenchmarkParams_Grid(100, 10000),
-        //SubtreeDomain);
-        ToposortSTDomain, ToposortDomain, PulsecountDomain, SubtreeDomain);
+    RUN_BENCHMARK(std::cout, 3, Benchmark_Grid, BenchmarkParams_Grid(100, 10000));
 
     //RUN_BENCHMARK(std::cout, 1, Benchmark_Grid, BenchmarkParams_Grid(30, 10000),
         //SourceSetDomain);
diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index e4fe6f5d..47a9494c 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -8,6 +8,7 @@
 #include <vector>
 #include <chrono>
 #include <thread>
+#include <tbb/tick_count.h>
 
 #include "react/Signal.h"
 #include "react/Event.h"
@@ -16,6 +17,97 @@
 
 using namespace react;
 
+
+template <typename T>
+class GridGraphGenerator
+{
+public:
+    using SignalType = Signal<T, shared>;
+
+    using Func1T = std::function<T(T)>;
+    using Func2T = std::function<T(T, T)>;
+
+    using SignalVectType = std::vector<SignalType>;
+
+    SignalVectType inputSignals;
+    SignalVectType outputSignals;
+
+    Func1T  function1;
+    Func2T  function2;
+
+    std::vector<size_t>  widths;
+
+    void Generate(const ReactiveGroupBase& group)
+    {
+        assert(inputSignals.size() >= 1);
+        assert(widths.size() >= 1);
+
+        SignalVectType buf1 = std::move(inputSignals);
+        SignalVectType buf2;
+
+        SignalVectType* curBuf = &buf1;
+        SignalVectType* nextBuf = &buf2;
+
+        size_t curWidth = buf1.size();
+
+        size_t nodeCount = 1;
+        nodeCount += curWidth;
+
+        for (auto targetWidth : widths)
+        {
+            while (curWidth != targetWidth)
+            {
+                // Grow or shrink?
+                bool shouldGrow = targetWidth > curWidth;
+
+                auto l = curBuf->begin();
+                auto r = curBuf->begin();
+                if (r != curBuf->end())
+                    ++r;
+
+                if (shouldGrow)
+                {
+										auto s = SignalType{ group, function1, *l };
+                    nextBuf->push_back(std::move(s));
+                }
+
+                while (r != curBuf->end())
+                {
+										auto s = SignalType{ group, function2, *l, *r };
+                    nextBuf->push_back(std::move(s));
+                    ++nodeCount;
+                    ++l; ++r;
+                }
+
+                if (shouldGrow)
+                {
+                    auto s = SignalType{ group, function1, *l };
+                    nextBuf->push_back(std::move(s));
+                    ++nodeCount;
+                }
+
+                curBuf->clear();
+
+                // Swap buffer pointers
+                SignalVectType* t = curBuf;
+                curBuf = nextBuf;
+                nextBuf = t;
+
+                if (shouldGrow)
+                    ++curWidth;
+                else
+                    --curWidth;
+            }
+        }
+
+        //printf ("NODE COUNT %d\n", nodeCount);
+
+        outputSignals.clear();
+        outputSignals.insert(outputSignals.begin(), curBuf->begin(), curBuf->end());
+    }
+};
+
+
 template <typename T>
 T Multiply(T a, T b)
 {
@@ -58,6 +150,16 @@ template <typename T> bool FilterFunc(T v)
 	return v > 10;
 }
 
+template <typename T> T IterFunc1(EventRange<T> evts, T v)
+{
+	return v + 1;
+}
+
+template <typename T> T IterFunc2(EventRange<T> evts, T v, T a1, T a2)
+{
+	return v + 1;
+}
+
 int main()
 {
 	ReactiveGroup<> group;
@@ -68,7 +170,7 @@ int main()
 		VarSignal<int> y{ group, 0 };
 		VarSignal<int> z{ group, 0 };
 
-		Signal<int> area{ group, Multiply<int>, x, y };
+		Signal<int> area{ Multiply<int>, x, y };
 		Signal<int> volume{ Multiply<int>, area, z };
 
 		Observer<> areaObs{ PrintArea<int>, area };
@@ -80,7 +182,7 @@ int main()
 
 		group.DoTransaction([&]
 		{
-			x <<= 100;
+			x.Set(100);
 			y <<= 3;
 			y <<= 4;
 		});
@@ -124,6 +226,7 @@ int main()
 		s2.Set(667);
 	}
 
+	// Links
 	{
 		ReactiveGroup<> group1;
 		ReactiveGroup<> group2;
@@ -144,25 +247,68 @@ int main()
 		ReactiveGroup<> group1;
 		ReactiveGroup<> group2;
 
-        VarSignal<int> s1{ group1, 10 };
+		VarSignal<int> s1{ group1, 10 };
+		VarSignal<int> s2{ group2, 11 };
+
+		EventSource<int> e1{ group1 };
+		EventSource<int> e2{ group2 };
+
+		auto hold = Hold(group1, 0, e1);
+
+		auto merged = Merge(group2, e1, e2);
+
+		auto joined1 = Join(e1, e2);
+		auto joined2 = Join(group1, e1, e2);
+
+		Observer<> eventObs1{ PrintEvents<int>, merged };
+		Observer<> eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
+
+		e1.Emit(222);
+
+		std::this_thread::sleep_for(std::chrono::seconds(5));
+	}
+
+	{
+		ReactiveGroup<> group1;
+		ReactiveGroup<> group2;
+
+		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
 
 		EventSource<int> e1{ group1 };
 		EventSource<int> e2{ group2 };
 
-        auto hold = Hold(group1, 0, e1);
+		auto hold1 = Hold(group1, 0, e1);
+		auto hold2 = Hold(0, e1);
+
+		auto monitor1 = Monitor(group1, s1);
+		auto monitor2 = Monitor(s1);
+
+		auto snapshot1 = Snapshot(group1, s1, e1);
+		auto snapshot2 = Snapshot(s1, e1);
+
+		auto pulse1 = Pulse(group1, s1, e1);
+		auto pulse2 = Pulse(s1, e1);
 
 		auto merged = Merge(group2, e1, e2);
 
-		auto joined = Join(e1, e2);
+		auto joined1 = Join(e1, e2);
 		auto joined2 = Join(group1, e1, e2);
 
+		auto iter1 = Iterate<int>(group, 0, IterFunc1<int>, e1);
+		auto iter2 = Iterate<int>(0, IterFunc1<int>, e1);
+
+		auto iter3 = Iterate<int>(group, 0, IterFunc2<int>, e1, s1, s2);
+		auto iter4 = Iterate<int>(0, IterFunc2<int>, e1, s1, s2);
+
 		Observer<> eventObs{ PrintEvents<int>, merged };
-        Observer<> eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
+		Observer<> eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
 
 		e1.Emit(222);
 
 		std::this_thread::sleep_for(std::chrono::seconds(5));
+
+		GridGraphGenerator<int> grid;
 	}
 
 	return 0;
@@ -178,7 +324,40 @@ int main()
 
 
 
+int main()
+{
+	ReactiveGroup<> group;
+
+	VarSignal<int, shared> in{ group, 1 };
+	Signal<int, shared> in2 = in;
+
+	GridGraphGenerator<int> generator;
+
+	generator.inputSignals.push_back(in2);
+
+	generator.widths.push_back(100);
+	generator.widths.push_back(1);
+
+	int updateCount = 0;
+
+	generator.function1 = [&] (int a) { ++updateCount; return a; };
+	generator.function2 = [&] (int a, int b) { ++updateCount; return a + b; };
+
+	generator.Generate(group);
+
+	updateCount = 0;
 
+	auto t0 = tbb::tick_count::now();
+	for (int i = 0; i < 10000; i++)
+		in <<= 10 + i;
+	auto t1 = tbb::tick_count::now();
+
+	double d = (t1 - t0).seconds();
+	printf("updateCount %d\n", updateCount);
+	printf("Time %g\n", d);
+
+	return 0;
+}
 
 
 
diff --git a/include/react/Signal.h b/include/react/Signal.h
index bd5f62df..0bff5126 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -77,13 +77,6 @@ class SignalBase
             PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
     }
 
-    template <typename F, typename T1, typename ... Ts>
-    auto CreateFuncNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
-    {
-        using REACT_IMPL::PrivateNodeInterface;
-        return CreateFuncNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
-    }
-
 private:
     std::shared_ptr<NodeType> nodePtr_;
 
@@ -266,16 +259,21 @@ class Signal<S, unique> : public SignalBase<S>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
+    // Construct from VarSignal
+    Signal(const VarSignalBase<S>& other) :
+        Signal::SignalBase( other )
+        { }
+
     // Construct func signal with explicit group
-    template <typename F, typename ... Ts>
-    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), deps ...) )
+    template <typename F, typename T1, typename ... Ts>
+    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
         { }
 
     // Construct func signal with implicit group
-    template <typename F, typename ... Ts>
-    explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
+    template <typename F, typename T1, typename ... Ts>
+    explicit Signal(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
         { }
 };
 
@@ -295,6 +293,11 @@ class Signal<S, shared> : public SignalBase<S>
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
+    // Construct from VarSignal
+    Signal(const VarSignalBase<S>& other) :
+        Signal::SignalBase( other )
+        { }
+
     // Construct from unique
     Signal(Signal<S, unique>&& other) :
         Signal::SignalBase( std::move(other) )
@@ -305,15 +308,15 @@ class Signal<S, shared> : public SignalBase<S>
         { Signal::SignalBase::operator=(std::move(other)); return *this; }
 
     // Construct func signal with explicit group
-    template <typename F, typename ... Ts>
-    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(std::forward<F>(func), deps ...) )
+    template <typename F, typename T1, typename ... Ts>
+    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
         { }
 
     // Construct func signal with implicit group
-    template <typename F, typename ... Ts>
-    explicit Signal(F&& func, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), deps ...) )
+    template <typename F, typename T1, typename ... Ts>
+    explicit Signal(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
+        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
         { }
 };
 
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index dbce7777..814fc94c 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -216,7 +216,7 @@ void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
     auto& node = nodeData_[nodeId];
     auto* nodePtr = node.nodePtr;
 
-    // This write to the input buffer of the respective node.
+    // This writes to the input buffer of the respective node.
     inputCallback();
     
     if (isTransactionActive_)

From 2a802161125aea0eb0864aa54a04e3b0d12f07eb Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 18 Dec 2016 13:45:36 +0100
Subject: [PATCH 41/75] refactor wip

---
 include/react/API.h       |  65 ++----
 include/react/Algorithm.h |  24 +--
 include/react/Event.h     | 360 +++++++++----------------------
 include/react/Group.h     |  58 +----
 include/react/Signal.h    | 442 +++++++++-----------------------------
 5 files changed, 235 insertions(+), 714 deletions(-)

diff --git a/include/react/API.h b/include/react/API.h
index b1e86ad1..dbd0e5df 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -17,12 +17,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// API constants
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-enum OwnershipPolicy
-{
-    unique,
-    shared
-};
-
 enum class WeightHint
 {
     automatic,
@@ -43,57 +37,34 @@ REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Groups
-template <OwnershipPolicy = unique>
 class ReactiveGroup;
 
 // Signals
 template <typename S>
-class SignalBase;
-
-template <typename S>
-class VarSignalBase;
-
-template <typename S>
-class SignalSlotBase;
-
-template <typename S>
-class SignalLinkBase;
-
-template <typename S, OwnershipPolicy = unique>
 class Signal;
 
-template <typename S, OwnershipPolicy = unique>
+template <typename S>
 class VarSignal;
 
-template <typename S, OwnershipPolicy = unique>
+template <typename S>
 class SignalSlot;
 
-template <typename S, OwnershipPolicy = unique>
+template <typename S>
 class SignalLink;
 
 // Events
 enum class Token;
 
-template <typename E>
-class EventBase;
-
-template <typename E>
-class EventSourceBase;
-
-template <typename E>
-class EventSlotBase;
-
-template <typename E = Token, OwnershipPolicy = unique>
+template <typename E = Token>
 class Event;
 
-template <typename E = Token, OwnershipPolicy = unique>
+template <typename E = Token>
 class EventSource;
 
-template <typename E, OwnershipPolicy = unique>
+template <typename E>
 class EventSlot;
 
 // Observers
-template <OwnershipPolicy = unique>
 class Observer;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -102,29 +73,29 @@ class Observer;
 template <typename T>
 struct IsSignal { static const bool value = false; };
 
-template <typename T, OwnershipPolicy ownership_policy>
-struct IsSignal<Signal<T, ownership_policy>> { static const bool value = true; };
+template <typename T>
+struct IsSignal<Signal<T>> { static const bool value = true; };
 
-template <typename T, OwnershipPolicy ownership_policy>
-struct IsSignal<VarSignal<T, ownership_policy>> { static const bool value = true; };
+template <typename T>
+struct IsSignal<VarSignal<T>> { static const bool value = true; };
 
 template <typename T>
 struct IsEvent { static const bool value = false; };
 
-template <typename T, OwnershipPolicy ownership_policy>
-struct IsEvent<Event<T, ownership_policy>> { static const bool value = true; };
+template <typename T>
+struct IsEvent<Event<T>> { static const bool value = true; };
 
-template <typename T, OwnershipPolicy ownership_policy>
-struct IsEvent<EventSource<T, ownership_policy>> { static const bool value = true; };
+template <typename T>
+struct IsEvent<EventSource<T>> { static const bool value = true; };
 
 template <typename T>
 struct AsNonInputNode { using type = T; };
 
-template <typename T, OwnershipPolicy ownership_policy>
-struct AsNonInputNode<VarSignal<T, ownership_policy>> { using type = Signal<T, ownership_policy>; };
+template <typename T>
+struct AsNonInputNode<VarSignal<T>> { using type = Signal<T>; };
 
-template <typename T, OwnershipPolicy ownership_policy>
-struct AsNonInputNode<EventSource<T, ownership_policy>> { using type = Event<T, ownership_policy>; };
+template <typename T>
+struct AsNonInputNode<EventSource<T>> { using type = Event<T>; };
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index 6a0037a2..b7e8324d 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -27,7 +27,7 @@
 /// Hold - Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, typename E>
-auto Hold(const ReactiveGroupBase& group, T&& initialValue, const EventBase<E>& evnt) -> Signal<E, unique>
+auto Hold(const ReactiveGroup& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
 {
     using REACT_IMPL::HoldNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
@@ -41,7 +41,7 @@ auto Hold(const ReactiveGroupBase& group, T&& initialValue, const EventBase<E>&
 }
 
 template <typename T, typename E>
-auto Hold(T&& initialValue, const EventBase<E>& evnt) -> Signal<E, unique>
+auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
 {
     using REACT_IMPL::HoldNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
@@ -58,7 +58,7 @@ auto Hold(T&& initialValue, const EventBase<E>& evnt) -> Signal<E, unique>
 /// Monitor - Emits value changes of target signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-auto Monitor(const ReactiveGroupBase& group, const SignalBase<S>& signal) -> Event<S, unique>
+auto Monitor(const ReactiveGroup& group, const Signal<S>& signal) -> Event<S>
 {
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -72,7 +72,7 @@ auto Monitor(const ReactiveGroupBase& group, const SignalBase<S>& signal) -> Eve
 }
 
 template <typename S>
-auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
+auto Monitor(const Signal<S>& signal) -> Event<S>
 {
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -89,7 +89,7 @@ auto Monitor(const SignalBase<S>& signal) -> Event<S, unique>
 /// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E>
-auto Iterate(const ReactiveGroupBase& group, T&& initialValue, F&& func, const EventBase<E>& evnt) -> Signal<S, unique>
+auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
@@ -111,7 +111,7 @@ auto Iterate(const ReactiveGroupBase& group, T&& initialValue, F&& func, const E
 }
 
 template <typename S, typename T, typename F, typename E>
-auto Iterate(T&& initialValue, F&& func, const EventBase<E>& evnt) -> Signal<S, unique>
+auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
@@ -136,7 +136,7 @@ auto Iterate(T&& initialValue, F&& func, const EventBase<E>& evnt) -> Signal<S,
 /// Iterate - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto Iterate(const ReactiveGroupBase& group, T&& initialValue, F&& func, const EventBase<E>& evnt, const SignalBase<Us>& ... signals) -> Signal<S, unique>
+auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
@@ -160,7 +160,7 @@ auto Iterate(const ReactiveGroupBase& group, T&& initialValue, F&& func, const E
 }
 
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto Iterate(T&& initialValue, F&& func, const EventBase<E>& evnt, const SignalBase<Us>& ... signals) -> Signal<S, unique>
+auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
@@ -187,7 +187,7 @@ auto Iterate(T&& initialValue, F&& func, const EventBase<E>& evnt, const SignalB
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Snapshot(const ReactiveGroupBase& group, const SignalBase<S>& signal, const EventBase<E>& evnt) -> Signal<S, unique>
+auto Snapshot(const ReactiveGroup& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -202,7 +202,7 @@ auto Snapshot(const ReactiveGroupBase& group, const SignalBase<S>& signal, const
 }
 
 template <typename S, typename E>
-auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& evnt) -> Signal<S, unique>
+auto Snapshot(const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -220,7 +220,7 @@ auto Snapshot(const SignalBase<S>& signal, const EventBase<E>& evnt) -> Signal<S
 /// Pulse - Emits value of target signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Pulse(const ReactiveGroupBase& group, const SignalBase<S>& signal, const EventBase<E>& evnt) -> Event<S, unique>
+auto Pulse(const ReactiveGroup& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
 {
     using REACT_IMPL::PulseNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -235,7 +235,7 @@ auto Pulse(const ReactiveGroupBase& group, const SignalBase<S>& signal, const Ev
 }
 
 template <typename S, typename E>
-auto Pulse(const SignalBase<S>& signal, const EventBase<E>& evnt) -> Event<S, unique>
+auto Pulse(const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
 {
     using REACT_IMPL::PulseNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
diff --git a/include/react/Event.h b/include/react/Event.h
index bf8c0a05..da63eb35 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -28,18 +28,41 @@ struct PrivateEventLinkNodeInterface;
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Events
+/// Event
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E = Token>
-class EventBase
+template <typename E>
+class Event
 {
 private:
     using NodeType = REACT_IMPL::EventStreamNode<E>;
 
 public:
-    // Private node ctor
-    EventBase(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
+    Event() = default;
+
+    Event(const Event&) = default;
+    Event& operator=(const Event&) = default;
+
+    Event(Event&&) = default;
+    Event& operator=(Event&&) = default;
+
+    template <typename F, typename T>
+    Event(F&& func, const Event<T>& dep) :
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
+        { }
+
+    template <typename F, typename T>
+    Event(const ReactiveGroup& group, F&& func, const Event<T>& dep) :
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
+        { }
+
+    template <typename F, typename T, typename ... Us>
+    Event(F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        { }
+
+    template <typename F, typename T, typename ... Us>
+    Event(const ReactiveGroup& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
         { }
 
     auto Tokenize() const -> decltype(auto)
@@ -58,13 +81,10 @@ class EventBase
         { return REACT::Transform(*this, std::forward<F>(f)); }*/
 
 protected:
-    EventBase() = default;
-
-    EventBase(const EventBase&) = default;
-    EventBase& operator=(const EventBase&) = default;
-
-    EventBase(EventBase&&) = default;
-    EventBase& operator=(EventBase&&) = default;
+    // Internal node ctor
+    Event(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
 
     auto NodePtr() -> std::shared_ptr<NodeType>&
         { return nodePtr_; }
@@ -73,7 +93,7 @@ class EventBase
         { return nodePtr_; }
 
     template <typename F, typename T>
-    auto CreateProcessingNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
+    auto CreateProcessingNode(F&& func, const Event<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using EventNodeType = REACT_IMPL::EventProcessingNode<E, T, typename std::decay<F>::type>;
@@ -82,7 +102,7 @@ class EventBase
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedProcessingNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedProcessingNode(F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::GetCheckedGraphPtr;
         using REACT_IMPL::PrivateNodeInterface;
@@ -103,11 +123,22 @@ class EventBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSource
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E = Token>
-class EventSourceBase : public EventBase<E>
+template <typename E>
+class EventSource : public Event<E>
 {
 public:
-    using EventBase::EventBase;
+    EventSource() = default;
+
+    EventSource(const EventSource&) = default;
+    EventSource& operator=(const EventSource&) = default;
+
+    EventSource(EventSource&& other) = default;
+    EventSource& operator=(EventSource&& other) = default;
+
+    // Construct event source
+    explicit EventSource(const ReactiveGroup& group) :
+        EventSource::Event( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        { }
     
     void Emit(const E& value)
         { EmitValue(value); }
@@ -119,20 +150,14 @@ class EventSourceBase : public EventBase<E>
     void Emit()
         { EmitValue(Token::value); }
 
-    EventSourceBase& operator<<(const E& value)
+    EventSource& operator<<(const E& value)
         { EmitValue(e); return *this; }
 
-    EventSourceBase& operator<<(E&& value)
+    EventSource& operator<<(E&& value)
         { EmitValue(std::move(value)); return *this; }
 
 protected:
-    EventSourceBase() = default;
-
-    EventSourceBase(const EventSourceBase&) = default;
-    EventSourceBase& operator=(const EventSourceBase&) = default;
 
-    EventSourceBase(EventSourceBase&& other) = default;
-    EventSourceBase& operator=(EventSourceBase&& other) = default;
 
     auto CreateSourceNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr) -> decltype(auto)
     {
@@ -160,27 +185,30 @@ class EventSourceBase : public EventBase<E>
 /// EventSlotBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class EventSlotBase : public EventBase<E>
+class EventSlot : public Event<E>
 {
 public:
-    using EventBase::EventBase;
+    EventSlot() = default;
 
-    void Set(const EventBase<E>& newInput)
-        { SetInput(newInput); }
+    EventSlot(const EventSlot&) = default;
+    EventSlot& operator=(const EventSlot&) = default;
 
-    void operator<<=(const EventBase<E>& newInput)
-        { SetInput(newInput); }
+    EventSlot(EventSlot&&) = default;
+    EventSlot& operator=(EventSlot&&) = default;
 
-protected:
-    EventSlotBase() = default;
+    // Construct with value
+    EventSlot(const ReactiveGroup& group, const Event<E>& input) :
+        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
 
-    EventSlotBase(const EventSlotBase&) = default;
-    EventSlotBase& operator=(const EventSlotBase&) = default;
+    void Set(const Event<E>& newInput)
+        { SetInput(newInput); }
 
-    EventSlotBase(EventSlotBase&&) = default;
-    EventSlotBase& operator=(EventSlotBase&&) = default;
+    void operator<<=(const Event<E>& newInput)
+        { SetInput(newInput); }
 
-    auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const EventBase<E>& input) -> decltype(auto)
+protected:
+    auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::PrivateReactiveGroupInterface;
@@ -190,7 +218,7 @@ class EventSlotBase : public EventBase<E>
     }
 
 private:
-    void SetInput(const EventBase<E>& newInput)
+    void SetInput(const Event<E>& newInput)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::NodeId;
@@ -206,24 +234,32 @@ class EventSlotBase : public EventBase<E>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventLinkBase
+/// EventLink
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class EventLinkBase : public EventBase<E>
+class EventLink : public Event<E>
 {
 public:
-    using EventBase::EventBase;
+    EventLink() = default;
 
-protected:
-    EventLinkBase() = default;
+    EventLink(const EventLink&) = default;
+    EventLink& operator=(const EventLink&) = default;
 
-    EventLinkBase(const EventLinkBase&) = default;
-    EventLinkBase& operator=(const EventLinkBase&) = default;
+    EventLink(EventLink&&) = default;
+    EventLink& operator=(EventLink&&) = default;
 
-    EventLinkBase(EventLinkBase&&) = default;
-    EventLinkBase& operator=(EventLinkBase&&) = default;
+    // Construct with explicit group
+    EventLink(const ReactiveGroup& group, const Event<E>& input) :
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
+
+    // Construct with implicit group
+    explicit EventLink(const Event<E>& input) :
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        { }
 
-    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const EventBase<E>& input) -> decltype(auto)
+protected:
+    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::PrivateReactiveGroupInterface;
@@ -237,207 +273,11 @@ class EventLinkBase : public EventBase<E>
     friend struct REACT_IMPL::PrivateEventLinkNodeInterface;
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Event
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class Event<E, unique> : public EventBase<E>
-{
-public:
-    using EventBase::EventBase;
-
-    using ValueType = E;
-
-    Event() = delete;
-
-    Event(const Event&) = delete;
-    Event& operator=(const Event&) = delete;
-
-    Event(Event&&) = default;
-    Event& operator=(Event&&) = default;
-
-    template <typename F, typename T>
-    Event(F&& func, const EventBase<T>& dep) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
-        { }
-
-    template <typename F, typename T>
-    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
-        { }
-
-    template <typename F, typename T, typename ... Us>
-    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
-        { }
-
-    template <typename F, typename T, typename ... Us>
-    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
-        { }
-};
-
-template <typename E>
-class Event<E, shared> : public EventBase<E>
-{
-public:
-    using EventBase::EventBase;
-
-    using ValueType = E;
-
-    Event() = delete;
-
-    Event(const Event&) = default;
-    Event& operator=(const Event&) = default;
-
-    Event(Event&&) = default;
-    Event& operator=(Event&&) = default;
-
-    Event(Event<E, unique>&& other) :
-        Event::EventBase( std::move(other) )
-        { }
-
-    Event& operator=(Event<E, unique>&& other)
-        { Event::EventBase::operator=(std::move(other)); return *this; }
-
-    template <typename F, typename T>
-    Event(F&& func, const EventBase<T>& dep) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
-        { }
-
-    template <typename F, typename T>
-    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
-        { }
-
-    template <typename F, typename T, typename ... Us>
-    Event(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
-        { }
-
-    template <typename F, typename T, typename ... Us>
-    Event(const ReactiveGroupBase& group, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... signals) :
-        Event::EventBase( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
-        { }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventSource
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class EventSource<E, unique> : public EventSourceBase<E>
-{
-public:
-    using EventSourceBase::EventSourceBase;
-
-    using ValueType = E;
-
-    EventSource() = delete;
-
-    EventSource(const EventSource&) = delete;
-    EventSource& operator=(const EventSource&) = delete;
-
-    EventSource(EventSource&&) = default;
-    EventSource& operator=(EventSource&&) = default;
-
-    // Construct event source
-    explicit EventSource(const ReactiveGroupBase& group) :
-        EventSource::EventSourceBase( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-};
-
-template <typename E>
-class EventSource<E, shared> : public EventSourceBase<E>
-{
-public:
-    using EventSourceBase::EventSourceBase;
-
-    using ValueType = E;
-
-    EventSource() = delete;
-
-    EventSource(const EventSource&) = default;
-    EventSource& operator=(const EventSource&) = default;
-
-    EventSource(EventSource&&) = default;
-    EventSource& operator=(EventSource&&) = default;
-
-    // Construct event source
-    explicit EventSource(const ReactiveGroupBase& group) :
-        EventSource::EventSourceBase( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct from unique
-    EventSource(EventSource<E, unique>&& other) :
-        EventSource::EventSourceBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    EventSource& operator=(EventSource<E, unique>&& other)
-        { EventSource::EventSourceBase::operator=(std::move(other)); return *this; }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventSlot
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E>
-class EventSlot<E, unique> : public EventSlotBase<E>
-{
-public:
-    using EventSlotBase::EventSlotBase;
-
-    using ValueType = E;
-
-    EventSlot() = delete;
-
-    EventSlot(const EventSlot&) = delete;
-    EventSlot& operator=(const EventSlot&) = delete;
-
-    EventSlot(EventSlot&&) = default;
-    EventSlot& operator=(EventSlot&&) = default;
-
-    // Construct with value
-    EventSlot(const ReactiveGroupBase& group, const EventBase<E>& input) :
-        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
-        { }
-};
-
-template <typename E>
-class EventSlot<E, shared> : public EventSlotBase<E>
-{
-public:
-    using EventSlotBase::EventSlotBase;
-
-    using ValueType = E;
-
-    EventSlot() = delete;
-
-    EventSlot(const EventSlot&) = default;
-    EventSlot& operator=(const EventSlot&) = default;
-
-    EventSlot(EventSlot&&) = default;
-    EventSlot& operator=(EventSlot&&) = default;
-
-    // Construct from unique
-    EventSlot(EventSlot<E, unique>&& other) :
-        EventSlot::EventSlotBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    EventSlot& operator=(EventSlot<E, unique>&& other)
-        { EventSlot::EventSlotBase::operator=(std::move(other)); return *this; }
-
-    // Construct with value
-    EventSlot(const ReactiveGroupBase& group, const SignalBase<E>& input) :
-        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
-        { }
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T = void, typename U1, typename ... Us>
-auto Merge(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype(auto)
+auto Merge(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 {
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
@@ -459,7 +299,7 @@ auto Merge(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const Even
 }
 
 template <typename T = void, typename U1, typename ... Us>
-auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype(auto)
+auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 {
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
@@ -484,7 +324,7 @@ auto Merge(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> decltype
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename F, typename E>
-auto Filter(const ReactiveGroupBase& group, F&& pred, const EventBase<E>& dep) -> Event<E, unique>
+auto Filter(const ReactiveGroup& group, F&& pred, const Event<E>& dep) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
         { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
@@ -493,7 +333,7 @@ auto Filter(const ReactiveGroupBase& group, F&& pred, const EventBase<E>& dep) -
 }
 
 template <typename F, typename E>
-auto Filter(F&& pred, const EventBase<E>& dep) -> Event<E, unique>
+auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
         { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
@@ -502,7 +342,7 @@ auto Filter(F&& pred, const EventBase<E>& dep) -> Event<E, unique>
 }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(const ReactiveGroupBase& group, F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals) -> Event<E, unique>
+auto Filter(const ReactiveGroup& group, F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
     {
@@ -515,7 +355,7 @@ auto Filter(const ReactiveGroupBase& group, F&& pred, const EventBase<E>& dep, c
 }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals) -> Event<E, unique>
+auto Filter(F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
     {
@@ -531,7 +371,7 @@ auto Filter(F&& pred, const EventBase<E>& dep, const SignalBase<Ts>& ... signals
 /// Transform
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E, typename F, typename T>
-auto Transform(const ReactiveGroupBase& group, F&& op, const EventBase<T>& dep) -> Event<E, unique>
+auto Transform(const ReactiveGroup& group, F&& op, const Event<T>& dep) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
         { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
@@ -540,7 +380,7 @@ auto Transform(const ReactiveGroupBase& group, F&& op, const EventBase<T>& dep)
 }
 
 template <typename E, typename F, typename T>
-auto Transform(F&& op, const EventBase<T>& dep) -> Event<E, unique>
+auto Transform(F&& op, const Event<T>& dep) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
         { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
@@ -549,7 +389,7 @@ auto Transform(F&& op, const EventBase<T>& dep) -> Event<E, unique>
 }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(const ReactiveGroupBase& group, F&& op, const EventBase<T>& dep, const SignalBase<Us>& ... signals) -> Event<E, unique>
+auto Transform(const ReactiveGroup& group, F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
     {
@@ -561,7 +401,7 @@ auto Transform(const ReactiveGroupBase& group, F&& op, const EventBase<T>& dep,
 }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(F&& op, const EventBase<T>& dep, const SignalBase<Us>& ... signals) -> Event<E, unique>
+auto Transform(F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
     {
@@ -587,7 +427,7 @@ auto Flatten(const Signal<Events<TInnerValue>>& outer) -> Events<TInnerValue>
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename U1, typename ... Us>
-auto Join(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> Event<std::tuple<U1, Us ...>, unique>
+auto Join(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::PrivateReactiveGroupInterface;
@@ -604,7 +444,7 @@ auto Join(const ReactiveGroupBase& group, const EventBase<U1>& dep1, const Event
 }
 
 template <typename U1, typename ... Us>
-auto Join(const EventBase<U1>& dep1, const EventBase<Us>& ... deps) -> Event<std::tuple<U1, Us ...>, unique>
+auto Join(const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::PrivateNodeInterface;
@@ -642,7 +482,7 @@ auto Tokenize(T&& source) -> decltype(auto)
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 template <typename L, typename R>
-bool Equals(const EventBase<L>& lhs, const EventBase<R>& rhs)
+bool Equals(const Event<L>& lhs, const Event<R>& rhs)
 {
     return lhs.Equals(rhs);
 }
@@ -650,7 +490,7 @@ bool Equals(const EventBase<L>& lhs, const EventBase<R>& rhs)
 struct PrivateEventLinkNodeInterface
 {
     template <typename E>
-    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const EventBase<E>& dep) -> std::shared_ptr<EventStreamNode<E>>
+    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const Event<E>& dep) -> std::shared_ptr<EventStreamNode<E>>
     {
         const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(dep);
 
diff --git a/include/react/Group.h b/include/react/Group.h
index ca2c02f0..837a2189 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -87,16 +87,20 @@ class TransactionStatus
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ReactiveGroupBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class ReactiveGroupBase
+class ReactiveGroup
 {
     using GraphType = REACT_IMPL::ReactiveGraph;
 
 public:
-    ReactiveGroupBase() :
+    ReactiveGroup() :
         graphPtr_( std::make_shared<GraphType>() )
         {  }
 
-    ~ReactiveGroupBase() = default;
+    ReactiveGroup(const ReactiveGroup&) = default;
+    ReactiveGroup& operator=(const ReactiveGroup&) = default;
+
+    ReactiveGroup(ReactiveGroup&& other) = default;
+    ReactiveGroup& operator=(ReactiveGroup&& other) = default;
 
     template <typename F>
     void DoTransaction(F&& func)
@@ -111,12 +115,6 @@ class ReactiveGroupBase
         { graphPtr_->EnqueueTransaction(flags, std::forward<F>(func)); }
 
 protected:
-    ReactiveGroupBase(const ReactiveGroupBase&) = default;
-    ReactiveGroupBase& operator=(const ReactiveGroupBase&) = default;
-
-    ReactiveGroupBase(ReactiveGroupBase&& other) = default;
-    ReactiveGroupBase& operator=(ReactiveGroupBase&& other) = default;
-
     auto GraphPtr() -> std::shared_ptr<GraphType>&
         { return graphPtr_; }
 
@@ -129,44 +127,6 @@ class ReactiveGroupBase
     friend struct REACT_IMPL::PrivateReactiveGroupInterface;
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signal
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <>
-class ReactiveGroup<unique> : public ReactiveGroupBase
-{
-public:
-    ReactiveGroup() = default;
-
-    ReactiveGroup(const ReactiveGroup&) = delete;
-    ReactiveGroup& operator=(const ReactiveGroup&) = delete;
-
-    ReactiveGroup(ReactiveGroup&& other) = default;
-    ReactiveGroup& operator=(ReactiveGroup&& other) = default;
-};
-
-template <>
-class ReactiveGroup<shared> : public ReactiveGroupBase
-{
-public:
-    ReactiveGroup() = default;
-
-    ReactiveGroup(const ReactiveGroup&) = default;
-    ReactiveGroup& operator=(const ReactiveGroup&) = default;
-
-    ReactiveGroup(ReactiveGroup&& other) = default;
-    ReactiveGroup& operator=(ReactiveGroup&& other) = default;
-
-    // Construct from unique
-    ReactiveGroup(ReactiveGroup<unique>&& other) :
-        ReactiveGroup::ReactiveGroupBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    ReactiveGroup& operator=(ReactiveGroup<unique>&& other)
-        { ReactiveGroup::ReactiveGroupBase::operator=(std::move(other)); return *this; }
-};
-
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
@@ -192,10 +152,10 @@ struct PrivateNodeInterface
 
 struct PrivateReactiveGroupInterface
 {
-    static auto GraphPtr(const ReactiveGroupBase& group) -> const std::shared_ptr<ReactiveGraph>&
+    static auto GraphPtr(const ReactiveGroup& group) -> const std::shared_ptr<ReactiveGraph>&
         { return group.GraphPtr(); }
 
-    static auto GraphPtr(ReactiveGroupBase& group) -> std::shared_ptr<ReactiveGraph>&
+    static auto GraphPtr(ReactiveGroup& group) -> std::shared_ptr<ReactiveGraph>&
         { return group.GraphPtr(); }
 };
 
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 0bff5126..786710d3 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -33,31 +33,46 @@ struct PrivateSignalLinkNodeInterface;
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalBase
+/// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalBase
+class Signal
 {
 private:
     using NodeType = REACT_IMPL::SignalNode<S>;
 
 public:
-    // Private node ctor
-    SignalBase(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-        { }
-
     const S& Value() const
         { return nodePtr_->Value(); }
 
-protected:
-    SignalBase() = default;
+    // Empty signal
+    Signal() = default;
 
-    SignalBase(const SignalBase&) = default;
-    SignalBase& operator=(const SignalBase&) = default;
+    // Copy ctor & assignment
+    Signal(const Signal&) = default;
+    Signal& operator=(const Signal&) = default;
 
-    SignalBase(SignalBase&&) = default;
-    SignalBase& operator=(SignalBase&&) = default;
+    // Move ctor & assignment
+    Signal(Signal&&) = default;
+    Signal& operator=(Signal&&) = default;
+
+    // Construct func signal with explicit group
+    template <typename F, typename T1, typename ... Ts>
+    explicit Signal(const ReactiveGroup& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
+        Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
+        { }
+
+    // Construct func signal with implicit group
+    template <typename F, typename T1, typename ... Ts>
+    explicit Signal(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
+        Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
+        { }
+
+protected:
+    // Private node ctor
+    Signal(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
 
     auto NodePtr() -> std::shared_ptr<NodeType>&
         { return nodePtr_; }
@@ -66,7 +81,7 @@ class SignalBase
         { return nodePtr_; }
 
     template <typename F, typename T1, typename ... Ts>
-    auto CreateFuncNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
+    auto CreateFuncNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using FuncNodeType = REACT_IMPL::SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>;
@@ -85,13 +100,32 @@ class SignalBase
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// VarSignalBase
+/// VarSignal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class VarSignalBase : public SignalBase<S>
+class VarSignal : public Signal<S>
 {
 public:
-    using SignalBase::SignalBase;
+    using Signal::Signal;
+
+    VarSignal() = default;
+
+    VarSignal(const VarSignal&) = default;
+    VarSignal& operator=(const VarSignal&) = default;
+
+    VarSignal(VarSignal&&) = default;
+    VarSignal& operator=(VarSignal&&) = default;
+
+    // Construct with group + default
+    explicit VarSignal(const ReactiveGroup& group) :
+        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        { }
+
+    // Construct with group + value
+    template <typename T>
+    VarSignal(const ReactiveGroup& group, T&& value) :
+        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value)) )
+        { }
 
     void Set(const S& newValue)
         { SetValue(newValue); }
@@ -110,14 +144,6 @@ class VarSignalBase : public SignalBase<S>
         { ModifyValue(func); }
 
 protected:
-    VarSignalBase() = default;
-
-    VarSignalBase(const VarSignalBase&) = default;
-    VarSignalBase& operator=(const VarSignalBase&) = default;
-
-    VarSignalBase(VarSignalBase&&) = default;
-    VarSignalBase& operator=(VarSignalBase&&) = default;
-
     static auto CreateVarNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr) -> decltype(auto)
     {
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
@@ -165,27 +191,38 @@ class VarSignalBase : public SignalBase<S>
 /// SignalSlotBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalSlotBase : public SignalBase<S>
+class SignalSlot : public Signal<S>
 {
 public:
-    using SignalBase::SignalBase;
+    SignalSlot(const SignalSlot&) = default;
+    SignalSlot& operator=(const SignalSlot&) = default;
 
-    void Set(const SignalBase<S>& newInput)
-        { SetInput(newInput); }
+    SignalSlot(SignalSlot&&) = default;
+    SignalSlot& operator=(SignalSlot&&) = default;
 
-    void operator<<=(const SignalBase<S>& newInput)
-        { SetInput(newInput); }
+    // Construct with group + default
+    explicit SignalSlot(const ReactiveGroup& group) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        { }
 
-protected:
-    SignalSlotBase() = default;
+    // Construct with group + value
+    SignalSlot(const ReactiveGroup& group, const Signal<S>& input) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
+
+    // Construct with value
+    explicit SignalSlot(const Signal<S>& input) :
+        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        { }
 
-    SignalSlotBase(const SignalSlotBase&) = default;
-    SignalSlotBase& operator=(const SignalSlotBase&) = default;
+    void Set(const Signal<S>& newInput)
+        { SetInput(newInput); }
 
-    SignalSlotBase(SignalSlotBase&&) = default;
-    SignalSlotBase& operator=(SignalSlotBase&&) = default;
+    void operator<<=(const Signal<S>& newInput)
+        { SetInput(newInput); }
 
-    static auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const SignalBase<S>& input) -> decltype(auto)
+protected:
+    static auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
@@ -194,7 +231,7 @@ class SignalSlotBase : public SignalBase<S>
     }
 
 private:
-    void SetInput(const SignalBase<S>& newInput)
+    void SetInput(const Signal<S>& newInput)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::NodeId;
@@ -209,24 +246,32 @@ class SignalSlotBase : public SignalBase<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalLinkBase
+/// SignalLink
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalLinkBase : public SignalBase<S>
+class SignalLink : public Signal<S>
 {
 public:
-    using SignalBase::SignalBase;
+    SignalLink() = default;
 
-protected:
-    SignalLinkBase() = default;
+    SignalLink(const SignalLink&) = default;
+    SignalLink& operator=(const SignalLink&) = default;
 
-    SignalLinkBase(const SignalLinkBase&) = default;
-    SignalLinkBase& operator=(const SignalLinkBase&) = default;
+    SignalLink(SignalLink&&) = default;
+    SignalLink& operator=(SignalLink&&) = default;
 
-    SignalLinkBase(SignalLinkBase&&) = default;
-    SignalLinkBase& operator=(SignalLinkBase&&) = default;
+    // Construct with explicit group
+    SignalLink(const ReactiveGroup& group, const Signal<S>& input) :
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        { }
+
+    // Construct with implicit group
+    explicit SignalLink(const Signal<S>& input) :
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        { }
 
-    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const SignalBase<S>& input) -> decltype(auto)
+protected:
+    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::PrivateReactiveGroupInterface;
@@ -240,307 +285,12 @@ class SignalLinkBase : public SignalBase<S>
     friend struct REACT_IMPL::PrivateSignalLinkNodeInterface;
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signal
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class Signal<S, unique> : public SignalBase<S>
-{
-public:
-    using SignalBase::SignalBase;
-
-    using ValueType = S;
-
-    Signal() = delete;
-
-    Signal(const Signal&) = delete;
-    Signal& operator=(const Signal&) = delete;
-
-    Signal(Signal&&) = default;
-    Signal& operator=(Signal&&) = default;
-
-    // Construct from VarSignal
-    Signal(const VarSignalBase<S>& other) :
-        Signal::SignalBase( other )
-        { }
-
-    // Construct func signal with explicit group
-    template <typename F, typename T1, typename ... Ts>
-    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
-        { }
-
-    // Construct func signal with implicit group
-    template <typename F, typename T1, typename ... Ts>
-    explicit Signal(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
-        { }
-};
-
-template <typename S>
-class Signal<S, shared> : public SignalBase<S>
-{
-public:
-    using SignalBase::SignalBase;
-
-    using ValueType = S;
-
-    Signal() = delete;
-
-    Signal(const Signal&) = default;
-    Signal& operator=(const Signal&) = default;
-
-    Signal(Signal&&) = default;
-    Signal& operator=(Signal&&) = default;
-
-    // Construct from VarSignal
-    Signal(const VarSignalBase<S>& other) :
-        Signal::SignalBase( other )
-        { }
-
-    // Construct from unique
-    Signal(Signal<S, unique>&& other) :
-        Signal::SignalBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    Signal& operator=(Signal<S, unique>&& other)
-        { Signal::SignalBase::operator=(std::move(other)); return *this; }
-
-    // Construct func signal with explicit group
-    template <typename F, typename T1, typename ... Ts>
-    explicit Signal(const ReactiveGroupBase& group, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
-        { }
-
-    // Construct func signal with implicit group
-    template <typename F, typename T1, typename ... Ts>
-    explicit Signal(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) :
-        Signal::SignalBase( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
-        { }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// VarSignal
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class VarSignal<S, unique> : public VarSignalBase<S>
-{
-public:
-    using VarSignalBase::VarSignalBase;
-
-    using ValueType = S;
-
-    VarSignal() = delete;
-
-    VarSignal(const VarSignal&) = delete;
-    VarSignal& operator=(const VarSignal&) = delete;
-
-    VarSignal(VarSignal&&) = default;
-    VarSignal& operator=(VarSignal&&) = default;
-
-    // Construct with group + default
-    explicit VarSignal(const ReactiveGroupBase& group) :
-        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct with group + value
-    template <typename T>
-    VarSignal(const ReactiveGroupBase& group, T&& value) :
-        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value)) )
-        { }
-};
-
-template <typename S>
-class VarSignal<S, shared> : public VarSignalBase<S>
-{
-public:
-    using VarSignalBase::VarSignalBase;
-
-    using ValueType = S;
-
-    VarSignal() = delete;
-
-    VarSignal(const VarSignal&) = default;
-    VarSignal& operator=(const VarSignal&) = default;
-
-    VarSignal(VarSignal&&) = default;
-    VarSignal& operator=(VarSignal&&) = default;
-
-    // Construct from unique
-    VarSignal(VarSignal<S, unique>&& other) :
-        VarSignal::VarSignalBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    VarSignal& operator=(VarSignal<S, unique>&& other)
-        { VarSignal::VarSignalBase::operator=(std::move(other)); return *this; }
-
-    // Construct with default
-    explicit VarSignal(const ReactiveGroupBase& group) :
-        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct with value
-    template <typename T>
-    VarSignal(const ReactiveGroupBase& group, T&& value) :
-        VarSignal::VarSignalBase( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value)) )
-        { }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalSlot
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class SignalSlot<S, unique> : public SignalSlotBase<S>
-{
-public:
-    using SignalSlotBase::SignalSlotBase;
-
-    using ValueType = S;
-
-    SignalSlot() = delete;
-
-    SignalSlot(const SignalSlot&) = delete;
-    SignalSlot& operator=(const SignalSlot&) = delete;
-
-    SignalSlot(SignalSlot&&) = default;
-    SignalSlot& operator=(SignalSlot&&) = default;
-
-    // Construct with group + default
-    explicit SignalSlot(const ReactiveGroupBase& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct with group + value
-    SignalSlot(const ReactiveGroupBase& group, const SignalBase<S>& input) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
-        { }
-
-    // Construct with value
-    explicit SignalSlot(const SignalBase<S>& input) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
-        { }
-};
-
-template <typename S>
-class SignalSlot<S, shared> : public SignalSlotBase<S>
-{
-public:
-    using SignalSlotBase::SignalSlotBase;
-
-    using ValueType = S;
-
-    SignalSlot() = delete;
-
-    SignalSlot(const SignalSlot&) = default;
-    SignalSlot& operator=(const SignalSlot&) = default;
-
-    SignalSlot(SignalSlot&&) = default;
-    SignalSlot& operator=(SignalSlot&&) = default;
-
-    // Construct from unique
-    SignalSlot(SignalSlot<S, unique>&& other) :
-        SignalSlot::SignalSlotBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    SignalSlot& operator=(SignalSlot<S, unique>&& other)
-        { SignalSlot::SignalSlotBase::operator=(std::move(other)); return *this; }
-
-    // Construct with group + default
-    explicit SignalSlot(const ReactiveGroupBase& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct with group + value
-    SignalSlot(const ReactiveGroupBase& group, const SignalBase<S>& input) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
-        { }
-
-    // Construct with value
-    explicit SignalSlot(const SignalBase<S>& input) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
-        { }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalLink
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class SignalLink<S, unique> : public SignalLinkBase<S>
-{
-public:
-    using SignalLinkBase::SignalLinkBase;
-
-    using ValueType = S;
-
-    SignalLink() = delete;
-
-    SignalLink(const SignalLink&) = delete;
-    SignalLink& operator=(const SignalLink&) = delete;
-
-    SignalLink(SignalLink&&) = default;
-    SignalLink& operator=(SignalLink&&) = default;
-
-    // Construct with default
-    explicit SignalLink(const ReactiveGroupBase& group) :
-        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct with group + value
-    SignalLink(const ReactiveGroupBase& group, const SignalBase<S>& input) :
-        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
-        { }
-
-    // Construct with value
-    explicit SignalLink(const SignalBase<S>& input) :
-        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
-        { }
-};
-
-template <typename S>
-class SignalLink<S, shared> : public SignalLinkBase<S>
-{
-public:
-    using SignalLinkBase::SignalLinkBase;
-
-    using ValueType = S;
-
-    SignalLink() = delete;
-
-    SignalLink(const SignalLink&) = default;
-    SignalLink& operator=(const SignalLink&) = default;
-
-    SignalLink(SignalLink&&) = default;
-    SignalLink& operator=(SignalLink&&) = default;
-
-    // Construct from unique
-    SignalLink(SignalLink<S, unique>&& other) :
-        SignalLink::SignalLinkBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    SignalLink& operator=(SignalSlot<S, unique>&& other)
-        { SignalLink::SignalLinkBase::operator=(std::move(other)); return *this; }
-
-    // Construct with default
-    explicit SignalLink(const ReactiveGroupBase& group) :
-        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
-        { }
-
-    // Construct with value
-    SignalLink(const ReactiveGroupBase& group, const SignalBase<S>& input) :
-        SignalLink::SignalLinkBase( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
-        { }
-};
-
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 template <typename L, typename R>
-bool Equals(const SignalBase<L>& lhs, const SignalBase<R>& rhs)
+bool Equals(const Signal<L>& lhs, const Signal<R>& rhs)
 {
     return lhs.Equals(rhs);
 }
@@ -548,7 +298,7 @@ bool Equals(const SignalBase<L>& lhs, const SignalBase<R>& rhs)
 struct PrivateSignalLinkNodeInterface
 {
     template <typename S>
-    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const SignalBase<S>& sig) -> std::shared_ptr<SignalNode<S>>
+    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const Signal<S>& sig) -> std::shared_ptr<SignalNode<S>>
     {
         const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(sig);
 

From 6ce444005409811361a8be2270b297881e753b89 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 18 Dec 2016 16:45:44 +0100
Subject: [PATCH 42/75] refactor wip

---
 examples/src/Main.cpp    |  56 ++++++------
 include/react/Event.h    |   4 +-
 include/react/Observer.h | 186 ++++++++++++---------------------------
 3 files changed, 84 insertions(+), 162 deletions(-)

diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 47a9494c..653d9d5e 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -22,7 +22,7 @@ template <typename T>
 class GridGraphGenerator
 {
 public:
-    using SignalType = Signal<T, shared>;
+    using SignalType = Signal<T>;
 
     using Func1T = std::function<T(T)>;
     using Func2T = std::function<T(T, T)>;
@@ -37,7 +37,7 @@ class GridGraphGenerator
 
     std::vector<size_t>  widths;
 
-    void Generate(const ReactiveGroupBase& group)
+    void Generate(const ReactiveGroup& group)
     {
         assert(inputSignals.size() >= 1);
         assert(widths.size() >= 1);
@@ -160,9 +160,9 @@ template <typename T> T IterFunc2(EventRange<T> evts, T v, T a1, T a2)
 	return v + 1;
 }
 
-int main()
+int main2()
 {
-	ReactiveGroup<> group;
+	ReactiveGroup group;
 
 	{
 		// Signals
@@ -173,8 +173,8 @@ int main()
 		Signal<int> area{ Multiply<int>, x, y };
 		Signal<int> volume{ Multiply<int>, area, z };
 
-		Observer<> areaObs{ PrintArea<int>, area };
-		Observer<> volumeObs{ PrintVolume<int>, volume };
+		Observer areaObs{ PrintArea<int>, area };
+		Observer volumeObs{ PrintVolume<int>, volume };
 
 		x.Set(2); // a: 0, v: 0
 		y.Set(2); // a: 4, v: 0
@@ -198,7 +198,7 @@ int main()
 		Event<int> anyButton = Merge(button1, button2);
 		Event<int> filtered  = Filter(FilterFunc<int>, anyButton);
 
-		Observer<> eventObs{ PrintEvents<int>, anyButton };
+		Observer eventObs{ PrintEvents<int>, anyButton };
 
 		button1.Emit(1);
 		button2.Emit(2);
@@ -217,7 +217,7 @@ int main()
 
 		SignalSlot<int> slot{ s1 };
 
-		Observer<> areaObs{ PrintValue<int>, slot };
+		Observer areaObs{ PrintValue<int>, slot };
 
 		s1.Set(42);
 
@@ -228,15 +228,15 @@ int main()
 
 	// Links
 	{
-		ReactiveGroup<> group1;
-		ReactiveGroup<> group2;
+		ReactiveGroup group1;
+		ReactiveGroup group2;
 
 		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
 
 		Signal<int> v{ Multiply<int>, s1, s2 };
 
-		Observer<> obs{ PrintValue<int>, v };
+		Observer obs{ PrintValue<int>, v };
 
 		s1.Set(555);
 
@@ -244,8 +244,8 @@ int main()
 	}
 
 	{
-		ReactiveGroup<> group1;
-		ReactiveGroup<> group2;
+		ReactiveGroup group1;
+		ReactiveGroup group2;
 
 		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
@@ -260,8 +260,8 @@ int main()
 		auto joined1 = Join(e1, e2);
 		auto joined2 = Join(group1, e1, e2);
 
-		Observer<> eventObs1{ PrintEvents<int>, merged };
-		Observer<> eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
+		Observer eventObs1{ PrintEvents<int>, merged };
+		Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
 
 		e1.Emit(222);
 
@@ -269,8 +269,8 @@ int main()
 	}
 
 	{
-		ReactiveGroup<> group1;
-		ReactiveGroup<> group2;
+		ReactiveGroup group1;
+		ReactiveGroup group2;
 
 		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
@@ -301,8 +301,8 @@ int main()
 		auto iter3 = Iterate<int>(group, 0, IterFunc2<int>, e1, s1, s2);
 		auto iter4 = Iterate<int>(0, IterFunc2<int>, e1, s1, s2);
 
-		Observer<> eventObs{ PrintEvents<int>, merged };
-		Observer<> eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
+		Observer eventObs{ PrintEvents<int>, merged };
+		Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
 
 		e1.Emit(222);
 
@@ -326,10 +326,10 @@ int main()
 
 int main()
 {
-	ReactiveGroup<> group;
+	ReactiveGroup group;
 
-	VarSignal<int, shared> in{ group, 1 };
-	Signal<int, shared> in2 = in;
+	VarSignal<int> in{ group, 1 };
+	Signal<int> in2 = in;
 
 	GridGraphGenerator<int> generator;
 
@@ -376,9 +376,9 @@ int main()
 
 /*int main2()
 {
-	ReactiveGroup<> group1;
-	ReactiveGroup<> group2;
-	ReactiveGroup<> group3;
+	ReactiveGroup group1;
+	ReactiveGroup group2;
+	ReactiveGroup group3;
 
 	VarSignal<int> x{ 0, group1 };
 	VarSignal<int> y{ 0, group2 };
@@ -387,7 +387,7 @@ int main()
 	Signal<int> area{ Multiply<int>, x, y };
 	Signal<int> volume{ Multiply<int>, area, z };
 
-	Observer<> obs{ PrintAreaAndVolume, area, volume };
+	Observer obs{ PrintAreaAndVolume, area, volume };
 
 	Signal<vector<int>> volumeHistory = Iterate<vector<int>>( vector<int>{ }, PushToVector, Monitor(volume));
 
@@ -420,8 +420,8 @@ int main3()
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group1;
-		ReactiveGroup<> group2;
+    ReactiveGroup group1;
+		ReactiveGroup group2;
 
     auto sig1 = VarSignal<int>( 10, group1 );
 
diff --git a/include/react/Event.h b/include/react/Event.h
index da63eb35..54d1ec85 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -294,7 +294,7 @@ auto Merge(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& .
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Event<E, unique>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
+    return Event<E>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
         graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
 }
 
@@ -316,7 +316,7 @@ auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
-    return Event<E, unique>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
+    return Event<E>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
         graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
 }
 
diff --git a/include/react/Observer.h b/include/react/Observer.h
index eea9ce5f..8d2be2a9 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -23,16 +23,55 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ObserverBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class ObserverBase
+class Observer
 {
 private:
     using NodeType = REACT_IMPL::ObserverNode;
 
 public:
-    // Private node ctor
-    explicit ObserverBase(std::shared_ptr<NodeType>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-        { }
+    Observer() = default;
+
+    Observer(const Observer&) = default;
+    Observer& operator=(const Observer&) = default;
+
+    Observer(Observer&&) = default;
+    Observer& operator=(Observer&&) = default;
+
+    // Construct signal observer with implicit group
+    template <typename F, typename ... Ts>
+    Observer(F&& func, const Signal<Ts>& ... subjects) :
+        Observer::Observer(CreateSignalObserverNode(std::forward<F>(func), subjects ...))
+    { }
+
+    // Construct signal observer with explicit group
+    template <typename F, typename ... Ts>
+    Observer(const ReactiveGroup& group, F&& func, const Signal<Ts>& ... subjects) :
+        Observer::Observer(CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...))
+    { }
+
+    // Construct event observer with implicit group
+    template <typename F, typename T>
+    Observer(F&& func, const Event<T>& subject) :
+        Observer::Observer(CreateEventObserverNode(std::forward<F>(func), subject))
+    { }
+
+    // Construct event observer with explicit group
+    template <typename F, typename T>
+    Observer(const ReactiveGroup& group, F&& func, const Event<T>& subject) :
+        Observer::Observer(CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject))
+    { }
+
+    // Constructed synced event observer with implicit group
+    template <typename F, typename T, typename ... Us>
+    Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
+        Observer::Observer(CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...))
+    { }
+
+    // Constructed synced event observer with explicit group
+    template <typename F, typename T, typename ... Us>
+    Observer(const ReactiveGroup& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
+        Observer::Observer(CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...))
+    { }
 
     void Cancel()
         { nodePtr_.reset(); }
@@ -41,13 +80,10 @@ class ObserverBase
         { return nodePtr_ != nullptr; }
 
 protected:
-    ObserverBase() = default;
-
-    ObserverBase(const ObserverBase&) = default;
-    ObserverBase& operator=(const ObserverBase&) = default;
-
-    ObserverBase(ObserverBase&&) = default;
-    ObserverBase& operator=(ObserverBase&&) = default;
+    // Private node ctor
+    explicit Observer(std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_(std::move(nodePtr))
+        { }
 
     auto NodePtr() -> std::shared_ptr<NodeType>&
         { return nodePtr_; }
@@ -56,7 +92,7 @@ class ObserverBase
         { return nodePtr_; }
 
     template <typename F, typename T1, typename ... Ts>
-    auto CreateSignalObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
+    auto CreateSignalObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>;
@@ -68,14 +104,14 @@ class ObserverBase
     }
 
     template <typename F, typename T1, typename ... Ts>
-    auto CreateSignalObserverNode(F&& func, const SignalBase<T1>& dep1, const SignalBase<Ts>& ... deps) -> decltype(auto)
+    auto CreateSignalObserverNode(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         return CreateSignalObserverNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
     }
 
     template <typename F, typename T>
-    auto CreateEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const EventBase<T>& dep) -> decltype(auto)
+    auto CreateEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Event<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::PrivateEventLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::EventObserverNode<typename std::decay<F>::type, T>;
@@ -84,14 +120,14 @@ class ObserverBase
     }
 
     template <typename F, typename T>
-    auto CreateEventObserverNode(F&& func, const EventBase<T>& dep) -> decltype(auto)
+    auto CreateEventObserverNode(F&& func, const Event<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         return CreateEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep);
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::PrivateEventLinkNodeInterface;
         using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -102,7 +138,7 @@ class ObserverBase
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(F&& func, const EventBase<T>& dep, const SignalBase<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedEventObserverNode(F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         return CreateSyncedEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep, syncs ...);
@@ -114,120 +150,6 @@ class ObserverBase
     friend struct REACT_IMPL::PrivateNodeInterface;
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Observer
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <>
-class Observer<unique> : public ObserverBase
-{
-public:
-    using ObserverBase::ObserverBase;
-
-    Observer() = delete;
-
-    Observer(const Observer&) = delete;
-    Observer& operator=(const Observer&) = delete;
-
-    Observer(Observer&&) = default;
-    Observer& operator=(Observer&&) = default;
-
-    // Construct signal observer with implicit group
-    template <typename F, typename ... Ts>
-    Observer(F&& func, const SignalBase<Ts>& ... subjects) :
-        Observer::ObserverBase( CreateSignalObserverNode(std::forward<F>(func), subjects ...) )
-        { }
-
-    // Construct signal observer with explicit group
-    template <typename F, typename ... Ts>
-    Observer(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... subjects) :
-        Observer::ObserverBase( CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...) )
-        { }
-
-    // Construct event observer with implicit group
-    template <typename F, typename T>
-    Observer(F&& func, const EventBase<T>& subject) :
-        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject) )
-        { }
-
-    // Construct event observer with explicit group
-    template <typename F, typename T>
-    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject) :
-        Observer::ObserverBase( CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject) )
-        { }
-
-    // Constructed synced event observer with implicit group
-    template <typename F, typename T, typename ... Us>
-    Observer(F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
-        Observer::ObserverBase( CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...) )
-        { }
-
-    // Constructed synced event observer with explicit group
-    template <typename F, typename T, typename ... Us>
-    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
-        Observer::ObserverBase( CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...) )
-        { }
-};
-
-template <>
-class Observer<shared> : public ObserverBase
-{
-public:
-    using ObserverBase::ObserverBase;
-
-    Observer() = delete;
-
-    Observer(const Observer&) = default;
-    Observer& operator=(const Observer&) = default;
-
-    Observer(Observer&&) = default;
-    Observer& operator=(Observer&&) = default;
-
-    // Construct from unique
-    Observer(Observer<unique>&& other) :
-        Observer::ObserverBase( std::move(other) )
-        { }
-
-    // Assign from unique
-    Observer& operator=(Observer<unique>&& other)
-        { Observer::ObserverBase::operator=(std::move(other)); return *this; }
-
-    // Construct signal observer with implicit group
-    template <typename F, typename ... Ts>
-    Observer(F&& func, const SignalBase<Ts>& ... subjects) :
-        Observer::ObserverBase( CreateSignalObserverNode(std::forward<F>(func), subjects ...) )
-        { }
-
-    // Construct signal observer with explicit group
-    template <typename F, typename ... Ts>
-    Observer(const ReactiveGroupBase& group, F&& func, const SignalBase<Ts>& ... subjects) :
-        Observer::ObserverBase( CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...) )
-        { }
-
-    // Construct event observer with implicit group
-    template <typename F, typename T>
-    Observer(F&& func, const EventBase<T>& subject) :
-        Observer::ObserverBase( CreateEventObserverNode(std::forward<F>(func), subject) )
-        { }
-
-    // Construct event observer with explicit group
-    template <typename F, typename T>
-    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject) :
-        Observer::ObserverBase( CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject) )
-        { }
-
-    // Constructed synced event observer with implicit group
-    template <typename F, typename T, typename ... Us>
-    Observer(F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
-        Observer::ObserverBase( CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...) )
-        { }
-
-    // Constructed synced event observer with explicit group
-    template <typename F, typename T, typename ... Us>
-    Observer(const ReactiveGroupBase& group, F&& func, const EventBase<T>& subject, const SignalBase<Us>& ... signals) :
-        Observer::ObserverBase( CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...) )
-        { }
-};
-
 /******************************************/ REACT_END /******************************************/
 
 #endif // REACT_OBSERVER_H_INCLUDED
\ No newline at end of file

From b7ec9da43ede547eaa0b42d61b79047cc168d722 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 18 Dec 2016 22:31:10 +0100
Subject: [PATCH 43/75] done getting rid of unique/shared wrapper types.
 everything is shared by default now.

---
 examples/src/BasicAlgorithms.cpp      | 16 +++----
 examples/src/BasicEvents.cpp          | 22 +++++-----
 examples/src/BasicObservers.cpp       |  8 ++--
 examples/src/BasicSignals.cpp         | 16 +++----
 include/react/Algorithm.h             | 62 +++++++++++++--------------
 include/react/Event.h                 | 42 +++++++++---------
 include/react/Group.h                 |  6 +++
 include/react/Observer.h              | 14 +++---
 include/react/Signal.h                |  8 ++--
 project/msvc/CppReact.vcxproj         |  1 -
 project/msvc/CppReact.vcxproj.filters |  3 --
 11 files changed, 99 insertions(+), 99 deletions(-)

diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index a11dbdb9..e804ec81 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -22,7 +22,7 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     struct Sensor
     {
@@ -36,7 +36,7 @@ namespace example1
 
         Sensor mySensor;
 
-        Observer<> obs(
+        Observer obs(
             [] (int v)
             {
                 cout << v << endl;
@@ -62,7 +62,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     struct Employee
     {
@@ -76,7 +76,7 @@ namespace example2
 
         Employee bob;
 
-        Observer<> obs(
+        Observer obs(
             [] (EventRange<int> in, const string& name)
             {
                 for (int newSalary : in)
@@ -96,7 +96,7 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     struct Counter
     {
@@ -137,7 +137,7 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     struct Sensor
     {
@@ -188,7 +188,7 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     enum ECmd { increment, decrement, reset };
 
@@ -255,7 +255,7 @@ namespace example6
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     class Sensor
     {
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index b9a7cfbd..97b795c2 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -22,7 +22,7 @@ namespace example1
     // Defines a group.
     // Each group represents a separate dependency graph.
     // Reactives from different groups can not be mixed.
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     // An event source that emits values of type string
     namespace v1
@@ -33,7 +33,7 @@ namespace example1
         {
             cout << "Example 1 - Hello world (string source)" << endl;
 
-            Observer<> obs(
+            Observer obs(
                 [] (EventRange<string> in)
                 {
                     for (const auto& s : in)
@@ -61,7 +61,7 @@ namespace example1
 
             int count = 0;
 
-            Observer<> obs(
+            Observer obs(
                 [&] (EventRange<> in)
                 {
                     for (auto t : in)
@@ -87,7 +87,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     // An event stream that merges both sources
     EventSource<> leftClick( group );
@@ -101,7 +101,7 @@ namespace example2
 
         int count = 0;
 
-        Observer<> obs(
+        Observer obs(
             [&] (EventRange<> in)
             {
                 for (auto t : in)
@@ -124,7 +124,7 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     EventSource<int> numbers( group );
 
@@ -134,7 +134,7 @@ namespace example3
     {
         cout << "Example 3 - Filtering events" << endl;
 
-        Observer<> obs(
+        Observer obs(
             [&] (EventRange<int> in)
             {
                 for (auto n : in)
@@ -156,7 +156,7 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     // Data types
     enum class Tag { normal, critical };
@@ -178,7 +178,7 @@ namespace example4
     {
         cout << "Example 4 - Transforming  events" << endl;
 
-        Observer<> obs(
+        Observer obs(
             [] (EventRange<TaggedNum> in)
             {
                 for (TaggedNum e : in)
@@ -206,7 +206,7 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     EventSource<int> src( group );
 
@@ -214,7 +214,7 @@ namespace example5
     {
         cout << "Example 5 - Queuing multiple inputs" << endl;
 
-        Observer<> obs(
+        Observer obs(
             [] (EventRange<int> in)
             {
                 for (int e : in)
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index c81cb372..261e5b88 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -20,7 +20,7 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     VarSignal<int> x( group, 1 );
 
@@ -31,7 +31,7 @@ namespace example1
         {
             Signal<int> mySignal( [] (int x) { return x; }, x );
 
-            Observer<> obs( [] (int mySignal) { cout << mySignal << endl; }, mySignal );
+            Observer obs( [] (int mySignal) { cout << mySignal << endl; }, mySignal );
 
             x <<= 2; // output: 2
         }
@@ -50,7 +50,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     EventSource<> trigger( group );
 
@@ -58,7 +58,7 @@ namespace example2
     {
         cout << "Example 2 - Detaching observers manually" << endl;
 
-        Observer<> obs(
+        Observer obs(
             [] (EventRange<> in)
             {
                 for (auto _ : in)
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index fc52eb68..995872dd 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -29,7 +29,7 @@ namespace example1
     // Defines a group.
     // Each group represents a separate dependency graph.
     // Reactives from different groups can not be mixed.
-    ReactiveGroup<> group;
+    ReactiveGroup group;
     
     // The two words
     VarSignal<string> firstWord( group, string("Change") );
@@ -64,7 +64,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     VarSignal<int> x( group, 1 );
 
@@ -74,7 +74,7 @@ namespace example2
     {
         cout << "Example 2 - Reacting to value changes" << endl;
 
-        Observer<> obs(
+        Observer obs(
             [] (int newValue) { cout << "xAbs changed to " << newValue << endl; },
             xAbs );
 
@@ -98,7 +98,7 @@ namespace example3
     int sumFunc(int a, int b)
         { return a + b; }
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     VarSignal<int> a( group, 1 );
     VarSignal<int> b( group, 1 );
@@ -111,7 +111,7 @@ namespace example3
     {
         cout << "Example 3 - Changing multiple inputs" << endl;
 
-        Observer<> obs(
+        Observer obs(
             [] (int newValue) { cout << "z changed to " << newValue << endl; },
             z );
 
@@ -136,7 +136,7 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     VarSignal<vector<string>> data( group );
 
@@ -167,7 +167,7 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    ReactiveGroup<> group;
+    ReactiveGroup group;
 
     // Helpers
     using ExprPairType = pair<string, int>;
@@ -204,7 +204,7 @@ namespace example5
     {
         cout << "Example 5 - Complex signals (v3)" << endl;
 
-        Observer<> obs(PrintExpressions, expressions);
+        Observer obs(PrintExpressions, expressions);
 
         a <<= 50;
         b <<= 60;
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index b7e8324d..f9ab8bb7 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -32,12 +32,13 @@ auto Hold(const ReactiveGroup& group, T&& initialValue, const Event<E>& evnt) ->
     using REACT_IMPL::HoldNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateNodeInterface;
     using REACT_IMPL::CtorTag;
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Signal<E, unique>( CtorTag{ }, std::make_shared<HoldNode<E>>(
-        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+    return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
+        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 template <typename T, typename E>
@@ -50,8 +51,8 @@ auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
 
-    return Signal<E, unique>( CtorTag{ }, std::make_shared<HoldNode<E>>(
-        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+    return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
+        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -63,12 +64,12 @@ auto Monitor(const ReactiveGroup& group, const Signal<S>& signal) -> Event<S>
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateReactiveGroupInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Event<S, unique>( CtorTag{ }, std::make_shared<MonitorNode<S>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal)) );
+    return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
 }
 
 template <typename S>
@@ -77,12 +78,11 @@ auto Monitor(const Signal<S>& signal) -> Event<S>
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
-    return Event<S, unique>( CtorTag{ }, std::make_shared<MonitorNode<S>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal)) );
+    return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -96,7 +96,7 @@ auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event
     using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateReactiveGroupInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -106,8 +106,8 @@ auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
-        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt) ));
+    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
+        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 template <typename S, typename T, typename F, typename E>
@@ -128,8 +128,8 @@ auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
 
-    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
-        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt) ));
+    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
+        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -144,7 +144,7 @@ auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateReactiveGroupInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -154,9 +154,9 @@ auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
+    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
         graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
-        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...));
+        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...);
 }
 
 template <typename S, typename T, typename F, typename E, typename ... Us>
@@ -168,7 +168,6 @@ auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>&
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -178,9 +177,9 @@ auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>&
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
 
-    return Signal<S, unique>( CtorTag{ }, std::make_shared<IterNodeType>(
+    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
         graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
-        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...));
+        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -193,12 +192,12 @@ auto Snapshot(const ReactiveGroup& group, const Signal<S>& signal, const Event<E
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateReactiveGroupInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Signal<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 template <typename S, typename E>
@@ -208,12 +207,11 @@ auto Snapshot(const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
-    return Signal<S, unique>( CtorTag{ }, std::make_shared<SnapshotNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -226,12 +224,12 @@ auto Pulse(const ReactiveGroup& group, const Signal<S>& signal, const Event<E>&
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;;
     using REACT_IMPL::PrivateReactiveGroupInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Event<S, unique>( CtorTag{ }, std::make_shared<PulseNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+    return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 template <typename S, typename E>
@@ -245,8 +243,8 @@ auto Pulse(const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
 
-    return Event<S, unique>( CtorTag{ }, std::make_shared<PulseNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt)) );
+    return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
+        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
 }
 
 /******************************************/ REACT_END /******************************************/
diff --git a/include/react/Event.h b/include/react/Event.h
index 54d1ec85..9151bc14 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -282,6 +282,7 @@ auto Merge(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& .
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateNodeInterface;
     using REACT_IMPL::CtorTag;
 
     static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
@@ -293,9 +294,9 @@ auto Merge(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& .
         T>::type;
 
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
-
-    return Event<E>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
+    
+    return PrivateNodeInterface::CreateNodeHelper<Event<E>, EventMergeNode<E, U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
 }
 
 template <typename T = void, typename U1, typename ... Us>
@@ -316,8 +317,8 @@ auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
-    return Event<E>( CtorTag{ }, std::make_shared<EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
+    return PrivateNodeInterface::CreateNodeHelper<Event<E>, EventMergeNode<E, U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -329,7 +330,7 @@ auto Filter(const ReactiveGroup& group, F&& pred, const Event<E>& dep) -> Event<
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
         { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
 
-    return Event<E, unique>(group, std::move(filterFunc), dep);
+    return Event<E>(group, std::move(filterFunc), dep);
 }
 
 template <typename F, typename E>
@@ -338,7 +339,7 @@ auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
         { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
 
-    return Event<E, unique>(std::move(filterFunc), dep);
+    return Event<E>(std::move(filterFunc), dep);
 }
 
 template <typename F, typename E, typename ... Ts>
@@ -351,7 +352,7 @@ auto Filter(const ReactiveGroup& group, F&& pred, const Event<E>& dep, const Sig
                 *out++ = v;
     };
 
-    return Event<E, unique>(group, std::move(filterFunc), dep, signals ...);
+    return Event<E>(group, std::move(filterFunc), dep, signals ...);
 }
 
 template <typename F, typename E, typename ... Ts>
@@ -364,7 +365,7 @@ auto Filter(F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Eve
                 *out++ = v;
     };
 
-    return Event<E, unique>(std::move(filterFunc), dep, signals ...);
+    return Event<E>(std::move(filterFunc), dep, signals ...);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -376,7 +377,7 @@ auto Transform(const ReactiveGroup& group, F&& op, const Event<T>& dep) -> Event
     auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
         { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
 
-    return Event<E, unique>(group, std::move(transformFunc), dep);
+    return Event<E>(group, std::move(transformFunc), dep);
 }
 
 template <typename E, typename F, typename T>
@@ -385,7 +386,7 @@ auto Transform(F&& op, const Event<T>& dep) -> Event<E>
     auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
         { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
 
-    return Event<E, unique>(std::move(transformFunc), dep);
+    return Event<E>(std::move(transformFunc), dep);
 }
 
 template <typename E, typename F, typename T, typename ... Us>
@@ -397,7 +398,7 @@ auto Transform(const ReactiveGroup& group, F&& op, const Event<T>& dep, const Si
             *out++ = capturedPred(v, values ...);
     };
 
-    return Event<E, unique>(group, std::move(transformFunc), dep, signals ...);
+    return Event<E>(group, std::move(transformFunc), dep, signals ...);
 }
 
 template <typename E, typename F, typename T, typename ... Us>
@@ -409,7 +410,7 @@ auto Transform(F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Ev
             *out++ = capturedPred(v, values ...);
     };
 
-    return Event<E, unique>(std::move(transformFunc), dep, signals ...);
+    return Event<E>(std::move(transformFunc), dep, signals ...);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -432,32 +433,31 @@ auto Join(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& ..
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::PrivateReactiveGroupInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
 
     // If supplied, use merge type, otherwise default to common type.
     const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
 
-    return Event<std::tuple<U1, Us ...>, unique>( CtorTag{ }, std::make_shared<EventJoinNode<U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
+    return PrivateNodeInterface::CreateNodeHelper<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
 }
 
 template <typename U1, typename ... Us>
 auto Join(const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
-    using REACT_IMPL::PrivateNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::CtorTag;
+    using REACT_IMPL::PrivateNodeInterface;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
 
     // If supplied, use merge type, otherwise default to common type.
     const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
 
-    return Event<std::tuple<U1, Us ...>, unique>( CtorTag{ }, std::make_shared<EventJoinNode<U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...));
+    return PrivateNodeInterface::CreateNodeHelper<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(
+        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -500,7 +500,7 @@ struct PrivateEventLinkNodeInterface
         }
         else
         {
-            return EventLinkBase<E>::CreateLinkNode(targetGraph, dep);
+            return EventLink<E>::CreateLinkNode(targetGraph, dep);
         }
     }
 };
diff --git a/include/react/Group.h b/include/react/Group.h
index 837a2189..050d070f 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -133,6 +133,12 @@ class ReactiveGroup
 
 struct PrivateNodeInterface
 {
+    // Free functions may have to access the private node constructor (i.e. Merge).
+    // Instead of making all of them friends, this helper function is used.
+    template <typename TResult, typename TNode, typename ... TArgs>
+    static auto CreateNodeHelper(TArgs&& ... args) -> decltype(auto)
+        { return TResult( CtorTag{ }, std::make_shared<TNode>(std::forward<TArgs>(args) ...)); }
+
     template <typename TBase>
     static auto NodePtr(const TBase& base) -> const std::shared_ptr<typename TBase::NodeType>&
         { return base.NodePtr(); }
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 8d2be2a9..c9d33072 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -40,37 +40,37 @@ class Observer
     // Construct signal observer with implicit group
     template <typename F, typename ... Ts>
     Observer(F&& func, const Signal<Ts>& ... subjects) :
-        Observer::Observer(CreateSignalObserverNode(std::forward<F>(func), subjects ...))
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(std::forward<F>(func), subjects ...))
     { }
 
     // Construct signal observer with explicit group
     template <typename F, typename ... Ts>
     Observer(const ReactiveGroup& group, F&& func, const Signal<Ts>& ... subjects) :
-        Observer::Observer(CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...))
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...))
     { }
 
     // Construct event observer with implicit group
     template <typename F, typename T>
     Observer(F&& func, const Event<T>& subject) :
-        Observer::Observer(CreateEventObserverNode(std::forward<F>(func), subject))
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(std::forward<F>(func), subject))
     { }
 
     // Construct event observer with explicit group
     template <typename F, typename T>
     Observer(const ReactiveGroup& group, F&& func, const Event<T>& subject) :
-        Observer::Observer(CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject))
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject))
     { }
 
     // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
     Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...))
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...))
     { }
 
     // Constructed synced event observer with explicit group
     template <typename F, typename T, typename ... Us>
     Observer(const ReactiveGroup& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...))
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...))
     { }
 
     void Cancel()
@@ -81,7 +81,7 @@ class Observer
 
 protected:
     // Private node ctor
-    explicit Observer(std::shared_ptr<NodeType>&& nodePtr) :
+    Observer(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_(std::move(nodePtr))
         { }
 
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 786710d3..79789527 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -202,17 +202,17 @@ class SignalSlot : public Signal<S>
 
     // Construct with group + default
     explicit SignalSlot(const ReactiveGroup& group) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
         { }
 
     // Construct with group + value
     SignalSlot(const ReactiveGroup& group, const Signal<S>& input) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
         { }
 
     // Construct with value
     explicit SignalSlot(const Signal<S>& input) :
-        SignalSlot::SignalSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
         { }
 
     void Set(const Signal<S>& newInput)
@@ -308,7 +308,7 @@ struct PrivateSignalLinkNodeInterface
         }
         else
         {
-            return SignalLinkBase<S>::CreateLinkNode(targetGraph, sig);
+            return SignalLink<S>::CreateLinkNode(targetGraph, sig);
         }
     }
 };
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 7ef4b0dc..ead65969 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -183,7 +183,6 @@
     <ClInclude Include="..\..\include\react\Signal.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\src\debug.cpp" />
     <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp" />
     <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp" />
     <ClCompile Include="..\..\src\engine\ToposortEngine.cpp" />
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index c5384429..76abe5da 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -122,8 +122,5 @@
     <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp">
       <Filter>Source Files\engine</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\debug.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file

From fc17e99dc8ff7d1fbe3a66c7ac1ae2465defc321 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 28 Dec 2016 14:01:31 +0100
Subject: [PATCH 44/75] refactor

---
 benchmarks/src/BenchmarkGrid.h         |  4 +-
 examples/src/BasicAlgorithms.cpp       | 12 ++--
 examples/src/BasicEvents.cpp           | 10 ++--
 examples/src/BasicObservers.cpp        |  4 +-
 examples/src/BasicSignals.cpp          | 10 ++--
 examples/src/BasicSynchronization.cpp  |  4 +-
 examples/src/Main.cpp                  | 28 ++++-----
 include/react/API.h                    |  2 +-
 include/react/Algorithm.h              | 36 ++++++------
 include/react/Event.h                  | 54 +++++++++---------
 include/react/Group.h                  | 79 +++++---------------------
 include/react/Observer.h               | 12 ++--
 include/react/Signal.h                 | 61 ++++++++------------
 include/react/detail/graph/GraphBase.h | 25 ++++----
 14 files changed, 138 insertions(+), 203 deletions(-)

diff --git a/benchmarks/src/BenchmarkGrid.h b/benchmarks/src/BenchmarkGrid.h
index 6b691cc3..d7ed0bb8 100644
--- a/benchmarks/src/BenchmarkGrid.h
+++ b/benchmarks/src/BenchmarkGrid.h
@@ -40,7 +40,7 @@ class GridGraphGenerator
 
     std::vector<size_t>  widths;
 
-    void Generate(const ReactiveGroupBase& group)
+    void Generate(const GroupBase& group)
     {
         assert(inputSignals.size() >= 1);
         assert(widths.size() >= 1);
@@ -132,7 +132,7 @@ struct BenchmarkParams_Grid
 
 struct Benchmark_Grid
 {
-    double Run(const BenchmarkParams_Grid& params, const ReactiveGroupBase& group)
+    double Run(const BenchmarkParams_Grid& params, const GroupBase& group)
     {
         VarSignal<int, shared> in{ group, 1 };
 				Signal<int, shared> in2 = in;
diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index e804ec81..c2c5d123 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -22,7 +22,7 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     struct Sensor
     {
@@ -62,7 +62,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     struct Employee
     {
@@ -96,7 +96,7 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     struct Counter
     {
@@ -137,7 +137,7 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     struct Sensor
     {
@@ -188,7 +188,7 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     enum ECmd { increment, decrement, reset };
 
@@ -255,7 +255,7 @@ namespace example6
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     class Sensor
     {
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index 97b795c2..da3fa4f2 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -22,7 +22,7 @@ namespace example1
     // Defines a group.
     // Each group represents a separate dependency graph.
     // Reactives from different groups can not be mixed.
-    ReactiveGroup group;
+    Group group;
 
     // An event source that emits values of type string
     namespace v1
@@ -87,7 +87,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     // An event stream that merges both sources
     EventSource<> leftClick( group );
@@ -124,7 +124,7 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     EventSource<int> numbers( group );
 
@@ -156,7 +156,7 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     // Data types
     enum class Tag { normal, critical };
@@ -206,7 +206,7 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     EventSource<int> src( group );
 
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index 261e5b88..ad263a2e 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -20,7 +20,7 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     VarSignal<int> x( group, 1 );
 
@@ -50,7 +50,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     EventSource<> trigger( group );
 
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 995872dd..6bd6771d 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -29,7 +29,7 @@ namespace example1
     // Defines a group.
     // Each group represents a separate dependency graph.
     // Reactives from different groups can not be mixed.
-    ReactiveGroup group;
+    Group group;
     
     // The two words
     VarSignal<string> firstWord( group, string("Change") );
@@ -64,7 +64,7 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     VarSignal<int> x( group, 1 );
 
@@ -98,7 +98,7 @@ namespace example3
     int sumFunc(int a, int b)
         { return a + b; }
 
-    ReactiveGroup group;
+    Group group;
 
     VarSignal<int> a( group, 1 );
     VarSignal<int> b( group, 1 );
@@ -136,7 +136,7 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     VarSignal<vector<string>> data( group );
 
@@ -167,7 +167,7 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group;
+    Group group;
 
     // Helpers
     using ExprPairType = pair<string, int>;
diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index a79f87ce..8eacfa6e 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -21,7 +21,7 @@ namespace example1
     using namespace react;
     using namespace std;
 
-    ReactiveGroup<> group;
+    Group<> group;
 
     class Sensor
     {
@@ -31,7 +31,7 @@ namespace example1
         Sensor(Sensor&&) = default;
         Sensor& operator=(Sensor&&) = default;
 
-        explicit Sensor(const ReactiveGroup<>& group) :
+        explicit Sensor(const Group<>& group) :
             Samples( group )
             { }
 
diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 653d9d5e..cc5fdc31 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -37,7 +37,7 @@ class GridGraphGenerator
 
     std::vector<size_t>  widths;
 
-    void Generate(const ReactiveGroup& group)
+    void Generate(const Group& group)
     {
         assert(inputSignals.size() >= 1);
         assert(widths.size() >= 1);
@@ -162,7 +162,7 @@ template <typename T> T IterFunc2(EventRange<T> evts, T v, T a1, T a2)
 
 int main2()
 {
-	ReactiveGroup group;
+	Group group;
 
 	{
 		// Signals
@@ -228,8 +228,8 @@ int main2()
 
 	// Links
 	{
-		ReactiveGroup group1;
-		ReactiveGroup group2;
+		Group group1;
+		Group group2;
 
 		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
@@ -244,8 +244,8 @@ int main2()
 	}
 
 	{
-		ReactiveGroup group1;
-		ReactiveGroup group2;
+		Group group1;
+		Group group2;
 
 		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
@@ -269,8 +269,8 @@ int main2()
 	}
 
 	{
-		ReactiveGroup group1;
-		ReactiveGroup group2;
+		Group group1;
+		Group group2;
 
 		VarSignal<int> s1{ group1, 10 };
 		VarSignal<int> s2{ group2, 11 };
@@ -326,7 +326,7 @@ int main2()
 
 int main()
 {
-	ReactiveGroup group;
+	Group group;
 
 	VarSignal<int> in{ group, 1 };
 	Signal<int> in2 = in;
@@ -376,9 +376,9 @@ int main()
 
 /*int main2()
 {
-	ReactiveGroup group1;
-	ReactiveGroup group2;
-	ReactiveGroup group3;
+	Group group1;
+	Group group2;
+	Group group3;
 
 	VarSignal<int> x{ 0, group1 };
 	VarSignal<int> y{ 0, group2 };
@@ -420,8 +420,8 @@ int main3()
     using namespace std;
     using namespace react;
 
-    ReactiveGroup group1;
-		ReactiveGroup group2;
+    Group group1;
+		Group group2;
 
     auto sig1 = VarSignal<int>( 10, group1 );
 
diff --git a/include/react/API.h b/include/react/API.h
index dbd0e5df..da892da8 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -37,7 +37,7 @@ REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Groups
-class ReactiveGroup;
+class Group;
 
 // Signals
 template <typename S>
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index f9ab8bb7..e5d6e076 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -27,15 +27,15 @@
 /// Hold - Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, typename E>
-auto Hold(const ReactiveGroup& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
+auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
 {
     using REACT_IMPL::HoldNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
     using REACT_IMPL::CtorTag;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
         graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
@@ -59,14 +59,14 @@ auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
 /// Monitor - Emits value changes of target signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-auto Monitor(const ReactiveGroup& group, const Signal<S>& signal) -> Event<S>
+auto Monitor(const Group& group, const Signal<S>& signal) -> Event<S>
 {
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
         graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
@@ -89,13 +89,13 @@ auto Monitor(const Signal<S>& signal) -> Event<S>
 /// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E>
-auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
     using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
 
     using FuncType = typename std::decay<F>::type;
@@ -104,7 +104,7 @@ auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event
         IterateNode<S, FuncType, E>,
         IterateByRefNode<S, FuncType, E>>::type;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
         graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
@@ -136,14 +136,14 @@ auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
 /// Iterate - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
+auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
     using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
 
     using FuncType = typename std::decay<F>::type;
@@ -152,7 +152,7 @@ auto Iterate(const ReactiveGroup& group, T&& initialValue, F&& func, const Event
         SyncedIterateNode<S, FuncType, E, Us ...>,
         SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
         graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
@@ -186,15 +186,15 @@ auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>&
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Snapshot(const ReactiveGroup& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
+auto Snapshot(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
         graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
@@ -218,15 +218,15 @@ auto Snapshot(const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
 /// Pulse - Emits value of target signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Pulse(const ReactiveGroup& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
+auto Pulse(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
 {
     using REACT_IMPL::PulseNode;
     using REACT_IMPL::PrivateSignalLinkNodeInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
         graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
diff --git a/include/react/Event.h b/include/react/Event.h
index 9151bc14..58e6ac4d 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -51,8 +51,8 @@ class Event
         { }
 
     template <typename F, typename T>
-    Event(const ReactiveGroup& group, F&& func, const Event<T>& dep) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
+    Event(const Group& group, F&& func, const Event<T>& dep) :
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T, typename ... Us>
@@ -61,8 +61,8 @@ class Event
         { }
 
     template <typename F, typename T, typename ... Us>
-    Event(const ReactiveGroup& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
+    Event(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
         { }
 
     auto Tokenize() const -> decltype(auto)
@@ -136,8 +136,8 @@ class EventSource : public Event<E>
     EventSource& operator=(EventSource&& other) = default;
 
     // Construct event source
-    explicit EventSource(const ReactiveGroup& group) :
-        EventSource::Event( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+    explicit EventSource(const Group& group) :
+        EventSource::Event( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group)) )
         { }
     
     void Emit(const E& value)
@@ -159,7 +159,7 @@ class EventSource : public Event<E>
 protected:
 
 
-    auto CreateSourceNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr) -> decltype(auto)
+    auto CreateSourceNode(const Group& group) -> decltype(auto)
     {
         using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
         return std::make_shared<SrcNodeType>(graphPtr);
@@ -197,8 +197,8 @@ class EventSlot : public Event<E>
     EventSlot& operator=(EventSlot&&) = default;
 
     // Construct with value
-    EventSlot(const ReactiveGroup& group, const Event<E>& input) :
-        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+    EventSlot(const Group& group, const Event<E>& input) :
+        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
         { }
 
     void Set(const Event<E>& newInput)
@@ -208,13 +208,13 @@ class EventSlot : public Event<E>
         { SetInput(newInput); }
 
 protected:
-    auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Event<E>& input) -> decltype(auto)
+    auto CreateSlotNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using REACT_IMPL::PrivateGroupInterface;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
 
-        return std::make_shared<SlotNodeType>(PrivateReactiveGroupInterface::GraphPtr(group), PrivateNodeInterface::NodePtr(input));
+        return std::make_shared<SlotNodeType>(group, input);
     }
 
 private:
@@ -249,8 +249,8 @@ class EventLink : public Event<E>
     EventLink& operator=(EventLink&&) = default;
 
     // Construct with explicit group
-    EventLink(const ReactiveGroup& group, const Event<E>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+    EventLink(const Group& group, const Event<E>& input) :
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(group, input) )
         { }
 
     // Construct with implicit group
@@ -259,13 +259,13 @@ class EventLink : public Event<E>
         { }
 
 protected:
-    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Event<E>& input) -> decltype(auto)
+    static auto CreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using REACT_IMPL::PrivateGroupInterface;
         using EventNodeType = REACT_IMPL::EventLinkNode<E>;
 
-        auto node = std::make_shared<EventNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
+        auto node = std::make_shared<EventNodeType>(group, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
         node->SetWeakSelfPtr(std::weak_ptr<EventNodeType>{ node });
         return node;
     }
@@ -277,11 +277,11 @@ class EventLink : public Event<E>
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T = void, typename U1, typename ... Us>
-auto Merge(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
+auto Merge(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 {
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateNodeInterface;
     using REACT_IMPL::CtorTag;
 
@@ -293,7 +293,7 @@ auto Merge(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& .
         typename std::common_type<U1, Us ...>::type,
         T>::type;
 
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
     
     return PrivateNodeInterface::CreateNodeHelper<Event<E>, EventMergeNode<E, U1, Us ...>>(
         graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
@@ -325,7 +325,7 @@ auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename F, typename E>
-auto Filter(const ReactiveGroup& group, F&& pred, const Event<E>& dep) -> Event<E>
+auto Filter(const Group& group, F&& pred, const Event<E>& dep) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
         { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
@@ -343,7 +343,7 @@ auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
 }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(const ReactiveGroup& group, F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
+auto Filter(const Group& group, F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
     {
@@ -372,7 +372,7 @@ auto Filter(F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Eve
 /// Transform
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E, typename F, typename T>
-auto Transform(const ReactiveGroup& group, F&& op, const Event<T>& dep) -> Event<E>
+auto Transform(const Group& group, F&& op, const Event<T>& dep) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
         { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
@@ -390,7 +390,7 @@ auto Transform(F&& op, const Event<T>& dep) -> Event<E>
 }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(const ReactiveGroup& group, F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
+auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
     {
@@ -428,17 +428,17 @@ auto Flatten(const Signal<Events<TInnerValue>>& outer) -> Events<TInnerValue>
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename U1, typename ... Us>
-auto Join(const ReactiveGroup& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
+auto Join(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
-    using REACT_IMPL::PrivateReactiveGroupInterface;
+    using REACT_IMPL::PrivateGroupInterface;
     using REACT_IMPL::PrivateEventLinkNodeInterface;
     using REACT_IMPL::PrivateNodeInterface;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
 
     // If supplied, use merge type, otherwise default to common type.
-    const auto& graphPtr = PrivateReactiveGroupInterface::GraphPtr(group);
+    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
 
     return PrivateNodeInterface::CreateNodeHelper<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(
         graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
diff --git a/include/react/Group.h b/include/react/Group.h
index 050d070f..6e9a645d 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DOMAIN_H_INCLUDED
-#define REACT_DOMAIN_H_INCLUDED
+#ifndef REACT_GROUP_H_INCLUDED
+#define REACT_GROUP_H_INCLUDED
 
 #pragma once
 
@@ -21,7 +21,7 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-struct PrivateReactiveGroupInterface;
+struct PrivateGroupInterface;
 struct CtorTag { };
 
 /****************************************/ REACT_IMPL_END /***************************************/
@@ -85,22 +85,22 @@ class TransactionStatus
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ReactiveGroupBase
+/// GroupBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class ReactiveGroup
+class Group
 {
     using GraphType = REACT_IMPL::ReactiveGraph;
 
 public:
-    ReactiveGroup() :
+    Group() :
         graphPtr_( std::make_shared<GraphType>() )
         {  }
 
-    ReactiveGroup(const ReactiveGroup&) = default;
-    ReactiveGroup& operator=(const ReactiveGroup&) = default;
+    Group(const Group&) = default;
+    Group& operator=(const Group&) = default;
 
-    ReactiveGroup(ReactiveGroup&& other) = default;
-    ReactiveGroup& operator=(ReactiveGroup&& other) = default;
+    Group(Group&& other) = default;
+    Group& operator=(Group&& other) = default;
 
     template <typename F>
     void DoTransaction(F&& func)
@@ -114,7 +114,8 @@ class ReactiveGroup
     void EnqueueTransaction(TransactionFlags flags, F&& func)
         { graphPtr_->EnqueueTransaction(flags, std::forward<F>(func)); }
 
-protected:
+
+public: // Internal
     auto GraphPtr() -> std::shared_ptr<GraphType>&
         { return graphPtr_; }
 
@@ -123,62 +124,8 @@ class ReactiveGroup
 
 private:
     std::shared_ptr<GraphType> graphPtr_;
-
-    friend struct REACT_IMPL::PrivateReactiveGroupInterface;
 };
 
 /******************************************/ REACT_END /******************************************/
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-struct PrivateNodeInterface
-{
-    // Free functions may have to access the private node constructor (i.e. Merge).
-    // Instead of making all of them friends, this helper function is used.
-    template <typename TResult, typename TNode, typename ... TArgs>
-    static auto CreateNodeHelper(TArgs&& ... args) -> decltype(auto)
-        { return TResult( CtorTag{ }, std::make_shared<TNode>(std::forward<TArgs>(args) ...)); }
-
-    template <typename TBase>
-    static auto NodePtr(const TBase& base) -> const std::shared_ptr<typename TBase::NodeType>&
-        { return base.NodePtr(); }
-
-    template <typename TBase>
-    static auto NodePtr(TBase& base) -> std::shared_ptr<typename TBase::NodeType>&
-        { return base.NodePtr(); }
-
-    template <typename TBase>
-    static auto GraphPtr(const TBase& base) -> const std::shared_ptr<ReactiveGraph>&
-        { return base.NodePtr()->GraphPtr(); }
-
-    template <typename TBase>
-    static auto GraphPtr(TBase& base) -> std::shared_ptr<ReactiveGraph>&
-        { return base.NodePtr()->GraphPtr(); }
-};
-
-struct PrivateReactiveGroupInterface
-{
-    static auto GraphPtr(const ReactiveGroup& group) -> const std::shared_ptr<ReactiveGraph>&
-        { return group.GraphPtr(); }
-
-    static auto GraphPtr(ReactiveGroup& group) -> std::shared_ptr<ReactiveGraph>&
-        { return group.GraphPtr(); }
-};
-
-template <typename TBase1, typename ... TBases>
-static auto GetCheckedGraphPtr(const TBase1& dep1, const TBases& ... deps) -> const std::shared_ptr<ReactiveGraph>&
-{
-    const std::shared_ptr<ReactiveGraph>& graphPtr1 = PrivateNodeInterface::GraphPtr(dep1);
-
-    std::initializer_list<ReactiveGraph*> rawGraphPtrs = { PrivateNodeInterface::GraphPtr(deps).get() ... };
-
-    bool isSameGraphForAllDeps = std::all_of(rawGraphPtrs.begin(), rawGraphPtrs.end(), [&] (ReactiveGraph* p) { return p == graphPtr1.get(); });
-
-    REACT_ASSERT(isSameGraphForAllDeps, "All dependencies must belong to the same group.");
-
-    return graphPtr1;
-}
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DOMAIN_H_INCLUDED
\ No newline at end of file
+#endif // REACT_GROUP_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Observer.h b/include/react/Observer.h
index c9d33072..0d2a82e0 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -45,8 +45,8 @@ class Observer
 
     // Construct signal observer with explicit group
     template <typename F, typename ... Ts>
-    Observer(const ReactiveGroup& group, F&& func, const Signal<Ts>& ... subjects) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...))
+    Observer(const Group& group, F&& func, const Signal<Ts>& ... subjects) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...))
     { }
 
     // Construct event observer with implicit group
@@ -57,8 +57,8 @@ class Observer
 
     // Construct event observer with explicit group
     template <typename F, typename T>
-    Observer(const ReactiveGroup& group, F&& func, const Event<T>& subject) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject))
+    Observer(const Group& group, F&& func, const Event<T>& subject) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), subject))
     { }
 
     // Constructed synced event observer with implicit group
@@ -69,8 +69,8 @@ class Observer
 
     // Constructed synced event observer with explicit group
     template <typename F, typename T, typename ... Us>
-    Observer(const ReactiveGroup& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...))
+    Observer(const Group& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...))
     { }
 
     void Cancel()
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 79789527..bc607a9f 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -42,24 +42,16 @@ class Signal
     using NodeType = REACT_IMPL::SignalNode<S>;
 
 public:
-    const S& Value() const
-        { return nodePtr_->Value(); }
-
-    // Empty signal
-    Signal() = default;
-
-    // Copy ctor & assignment
     Signal(const Signal&) = default;
     Signal& operator=(const Signal&) = default;
 
-    // Move ctor & assignment
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
     // Construct func signal with explicit group
     template <typename F, typename T1, typename ... Ts>
-    explicit Signal(const ReactiveGroup& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
-        Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
+    explicit Signal(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
+        Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
         { }
 
     // Construct func signal with implicit group
@@ -68,7 +60,10 @@ class Signal
         Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
         { }
 
-protected:
+    const Group& GetGroup() const
+        { return nodePtr_->GetGroup(); }
+
+public: // Internal
     // Private node ctor
     Signal(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
@@ -80,6 +75,7 @@ class Signal
     auto NodePtr() const -> const std::shared_ptr<NodeType>&
         { return nodePtr_; }
 
+protected:
     template <typename F, typename T1, typename ... Ts>
     auto CreateFuncNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
@@ -94,11 +90,8 @@ class Signal
 
 private:
     std::shared_ptr<NodeType> nodePtr_;
-
-    friend struct REACT_IMPL::PrivateNodeInterface;
 };
 
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// VarSignal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -106,10 +99,6 @@ template <typename S>
 class VarSignal : public Signal<S>
 {
 public:
-    using Signal::Signal;
-
-    VarSignal() = default;
-
     VarSignal(const VarSignal&) = default;
     VarSignal& operator=(const VarSignal&) = default;
 
@@ -117,14 +106,14 @@ class VarSignal : public Signal<S>
     VarSignal& operator=(VarSignal&&) = default;
 
     // Construct with group + default
-    explicit VarSignal(const ReactiveGroup& group) :
-        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+    explicit VarSignal(const Group& group) :
+        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(group) )
         { }
 
     // Construct with group + value
     template <typename T>
-    VarSignal(const ReactiveGroup& group, T&& value) :
-        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), std::forward<T>(value)) )
+    VarSignal(const Group& group, T&& value) :
+        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(group, std::forward<T>(value)) )
         { }
 
     void Set(const S& newValue)
@@ -144,14 +133,14 @@ class VarSignal : public Signal<S>
         { ModifyValue(func); }
 
 protected:
-    static auto CreateVarNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr) -> decltype(auto)
+    static auto CreateVarNode(const Group& group) -> decltype(auto)
     {
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
         return std::make_shared<VarNodeType>(graphPtr);
     }
 
     template <typename T>
-    static auto CreateVarNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, T&& value) -> decltype(auto)
+    static auto CreateVarNode(const Group& group, T&& value) -> decltype(auto)
     {
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
         return std::make_shared<VarNodeType>(graphPtr, std::forward<T>(value));
@@ -162,7 +151,6 @@ class VarSignal : public Signal<S>
     void SetValue(T&& newValue)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::ReactiveGraph;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
@@ -176,7 +164,6 @@ class VarSignal : public Signal<S>
     void ModifyValue(const F& func)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::ReactiveGraph;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
@@ -201,13 +188,13 @@ class SignalSlot : public Signal<S>
     SignalSlot& operator=(SignalSlot&&) = default;
 
     // Construct with group + default
-    explicit SignalSlot(const ReactiveGroup& group) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group)) )
+    explicit SignalSlot(const Group& group) :
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group)) )
         { }
 
     // Construct with group + value
-    SignalSlot(const ReactiveGroup& group, const Signal<S>& input) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+    SignalSlot(const Group& group, const Signal<S>& input) :
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), input) )
         { }
 
     // Construct with value
@@ -222,7 +209,7 @@ class SignalSlot : public Signal<S>
         { SetInput(newInput); }
 
 protected:
-    static auto CreateSlotNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Signal<S>& input) -> decltype(auto)
+    static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
         using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
@@ -252,8 +239,6 @@ template <typename S>
 class SignalLink : public Signal<S>
 {
 public:
-    SignalLink() = default;
-
     SignalLink(const SignalLink&) = default;
     SignalLink& operator=(const SignalLink&) = default;
 
@@ -261,20 +246,20 @@ class SignalLink : public Signal<S>
     SignalLink& operator=(SignalLink&&) = default;
 
     // Construct with explicit group
-    SignalLink(const ReactiveGroup& group, const Signal<S>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateReactiveGroupInterface::GraphPtr(group), input) )
+    SignalLink(const Group& group, const Signal<S>& input) :
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(group, input) )
         { }
 
     // Construct with implicit group
     explicit SignalLink(const Signal<S>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(input.GetGroup(), input) )
         { }
 
 protected:
-    static auto CreateLinkNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, const Signal<S>& input) -> decltype(auto)
+    static auto CreateLinkNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateReactiveGroupInterface;
+        using REACT_IMPL::PrivateGroupInterface;
         using LinkNodeType = REACT_IMPL::SignalLinkNode<S>;
 
         auto node = std::make_shared<LinkNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index d39809bb..3305ca40 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -29,8 +29,8 @@ class ReactiveGraph;
 class NodeBase : public IReactiveNode
 {
 public:
-    NodeBase(const std::shared_ptr<ReactiveGraph>& graphPtr) :
-        graphPtr_( graphPtr )
+    NodeBase(const Group& group) :
+        group_( group )
         { }
     
     NodeBase(const NodeBase&) = delete;
@@ -58,35 +58,38 @@ class NodeBase : public IReactiveNode
     NodeId GetNodeId() const
         { return nodeId_; }
 
+    const Group& GetGroup() const
+        { return group_; }
+
     auto GraphPtr() const -> const std::shared_ptr<ReactiveGraph>&
-        { return graphPtr_; }
+        { return GroupInternals::GraphPtr(group_); }
 
     auto GraphPtr() -> std::shared_ptr<ReactiveGraph>&
-        { return graphPtr_; }
+        { return GroupInternals::GraphPtr(group_); }
 
 protected:
     void RegisterMe(NodeCategory category = NodeCategory::normal)
-        { nodeId_ = graphPtr_->RegisterNode(this, category); }
+        { nodeId_ = GraphPtr()->RegisterNode(this, category); }
     
     void UnregisterMe()
-        { graphPtr_->UnregisterNode(nodeId_); }
+        { GraphPtr()->UnregisterNode(nodeId_); }
 
     void AttachToMe(NodeId otherNodeId)
-        { graphPtr_->OnNodeAttach(nodeId_, otherNodeId); }
+        { GraphPtr()->OnNodeAttach(nodeId_, otherNodeId); }
 
     void DetachFromMe(NodeId otherNodeId)
-        { graphPtr_->OnNodeDetach(nodeId_, otherNodeId); }
+        { GraphPtr()->OnNodeDetach(nodeId_, otherNodeId); }
 
     void DynamicAttachToMe(NodeId otherNodeId, TurnId turnId)
-        { graphPtr_->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
+        { GraphPtr()->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
 
     void DynamicDetachFromMe(NodeId otherNodeId, TurnId turnId)
-        { graphPtr_->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
+        { GraphPtr()->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
 
 private:
     NodeId nodeId_;
 
-    std::shared_ptr<ReactiveGraph> graphPtr_;
+    Group group_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/

From 1116f3a55ad263ebe21a48bbc9fc34e2662de7ed Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 28 Dec 2016 14:46:47 +0100
Subject: [PATCH 45/75] progress

---
 include/react/Event.h    | 21 ++++--------------
 include/react/Observer.h | 46 +++++++++++++++-------------------------
 2 files changed, 21 insertions(+), 46 deletions(-)

diff --git a/include/react/Event.h b/include/react/Event.h
index 58e6ac4d..d0dec01b 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -37,8 +37,6 @@ class Event
     using NodeType = REACT_IMPL::EventStreamNode<E>;
 
 public:
-    Event() = default;
-
     Event(const Event&) = default;
     Event& operator=(const Event&) = default;
 
@@ -52,7 +50,7 @@ class Event
 
     template <typename F, typename T>
     Event(const Group& group, F&& func, const Event<T>& dep) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), dep) )
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(group, std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T, typename ... Us>
@@ -62,7 +60,7 @@ class Event
 
     template <typename F, typename T, typename ... Us>
     Event(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), dep, signals ...) )
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(group, std::forward<F>(func), dep, signals ...) )
         { }
 
     auto Tokenize() const -> decltype(auto)
@@ -127,8 +125,6 @@ template <typename E>
 class EventSource : public Event<E>
 {
 public:
-    EventSource() = default;
-
     EventSource(const EventSource&) = default;
     EventSource& operator=(const EventSource&) = default;
 
@@ -137,7 +133,7 @@ class EventSource : public Event<E>
 
     // Construct event source
     explicit EventSource(const Group& group) :
-        EventSource::Event( REACT_IMPL::CtorTag{ }, CreateSourceNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group)) )
+        EventSource::Event( REACT_IMPL::CtorTag{ }, CreateSourceNode(group) )
         { }
     
     void Emit(const E& value)
@@ -157,12 +153,10 @@ class EventSource : public Event<E>
         { EmitValue(std::move(value)); return *this; }
 
 protected:
-
-
     auto CreateSourceNode(const Group& group) -> decltype(auto)
     {
         using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
-        return std::make_shared<SrcNodeType>(graphPtr);
+        return std::make_shared<SrcNodeType>(group);
     }
 
 private:
@@ -188,8 +182,6 @@ template <typename E>
 class EventSlot : public Event<E>
 {
 public:
-    EventSlot() = default;
-
     EventSlot(const EventSlot&) = default;
     EventSlot& operator=(const EventSlot&) = default;
 
@@ -210,8 +202,6 @@ class EventSlot : public Event<E>
 protected:
     auto CreateSlotNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateGroupInterface;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
 
         return std::make_shared<SlotNodeType>(group, input);
@@ -220,7 +210,6 @@ class EventSlot : public Event<E>
 private:
     void SetInput(const Event<E>& newInput)
     {
-        using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::NodeId;
         using REACT_IMPL::ReactiveGraph;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
@@ -240,8 +229,6 @@ template <typename E>
 class EventLink : public Event<E>
 {
 public:
-    EventLink() = default;
-
     EventLink(const EventLink&) = default;
     EventLink& operator=(const EventLink&) = default;
 
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 0d2a82e0..b0b64c8e 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -29,8 +29,6 @@ class Observer
     using NodeType = REACT_IMPL::ObserverNode;
 
 public:
-    Observer() = default;
-
     Observer(const Observer&) = default;
     Observer& operator=(const Observer&) = default;
 
@@ -41,45 +39,39 @@ class Observer
     template <typename F, typename ... Ts>
     Observer(F&& func, const Signal<Ts>& ... subjects) :
         Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(std::forward<F>(func), subjects ...))
-    { }
+        { }
 
     // Construct signal observer with explicit group
     template <typename F, typename ... Ts>
     Observer(const Group& group, F&& func, const Signal<Ts>& ... subjects) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), subjects ...))
-    { }
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(group, std::forward<F>(func), subjects ...))
+        { }
 
     // Construct event observer with implicit group
     template <typename F, typename T>
     Observer(F&& func, const Event<T>& subject) :
         Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(std::forward<F>(func), subject))
-    { }
+        { }
 
     // Construct event observer with explicit group
     template <typename F, typename T>
     Observer(const Group& group, F&& func, const Event<T>& subject) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), subject))
-    { }
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(group, std::forward<F>(func), subject))
+        { }
 
     // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
     Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
         Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...))
-    { }
+        { }
 
     // Constructed synced event observer with explicit group
     template <typename F, typename T, typename ... Us>
     Observer(const Group& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), subject, signals ...))
-    { }
-
-    void Cancel()
-        { nodePtr_.reset(); }
-
-    bool IsCancelled() const
-        { return nodePtr_ != nullptr; }
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, signals ...))
+        { }
 
-protected:
+public: //Internal
     // Private node ctor
     Observer(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_(std::move(nodePtr))
@@ -91,14 +83,15 @@ class Observer
     auto NodePtr() const -> const std::shared_ptr<NodeType>&
         { return nodePtr_; }
 
+protected:
     template <typename F, typename T1, typename ... Ts>
-    auto CreateSignalObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
+    auto CreateSignalObserverNode(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::PrivateSignalLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>;
 
         return std::make_shared<ObsNodeType>(
-            graphPtr,
+            group,
             std::forward<F>(func),
             PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
     }
@@ -106,28 +99,26 @@ class Observer
     template <typename F, typename T1, typename ... Ts>
     auto CreateSignalObserverNode(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
         return CreateSignalObserverNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
     }
 
     template <typename F, typename T>
-    auto CreateEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Event<T>& dep) -> decltype(auto)
+    auto CreateEventObserverNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::PrivateEventLinkNodeInterface;
         using ObsNodeType = REACT_IMPL::EventObserverNode<typename std::decay<F>::type, T>;
 
-        return std::make_shared<ObsNodeType>(graphPtr, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep));
+        return std::make_shared<ObsNodeType>(group, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep));
     }
 
     template <typename F, typename T>
     auto CreateEventObserverNode(F&& func, const Event<T>& dep) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
         return CreateEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep);
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedEventObserverNode(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::PrivateEventLinkNodeInterface;
         using REACT_IMPL::PrivateSignalLinkNodeInterface;
@@ -140,14 +131,11 @@ class Observer
     template <typename F, typename T, typename ... Us>
     auto CreateSyncedEventObserverNode(F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
         return CreateSyncedEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep, syncs ...);
     }
 
 private:
-    std::shared_ptr<NodeType> nodePtr_;
-
-    friend struct REACT_IMPL::PrivateNodeInterface;
+    std::shared_ptr<NodeType> nodePtr_;s
 };
 
 /******************************************/ REACT_END /******************************************/

From d7c2e2dde4439c0196d8d141b1c5b3f947008bba Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 1 Jan 2017 23:49:19 +0100
Subject: [PATCH 46/75] wip refactoring

---
 include/react/Algorithm.h                   | 147 +----------
 include/react/Event.h                       | 266 +++++++++-----------
 include/react/Group.h                       |  62 +++--
 include/react/Observer.h                    |  80 ++----
 include/react/Signal.h                      | 217 ++++++++--------
 include/react/detail/Defs.h                 |  18 +-
 include/react/detail/graph/AlgorithmNodes.h |  54 ++--
 include/react/detail/graph/EventNodes.h     |  92 +++----
 include/react/detail/graph/GraphBase.h      |  27 +-
 include/react/detail/graph/ObserverNodes.h  |  51 ++--
 include/react/detail/graph/SignalNodes.h    |  99 ++++----
 11 files changed, 476 insertions(+), 637 deletions(-)

diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index e5d6e076..babc4c8b 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -30,30 +30,12 @@ template <typename T, typename E>
 auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
 {
     using REACT_IMPL::HoldNode;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
-
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
-        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
+    return Signal<E>::CreateWithNode<HoldNode<E>>(group, std::forward<T>(initialValue), SameGroupOrLink(group, evnt));
 }
 
 template <typename T, typename E>
 auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
-{
-    using REACT_IMPL::HoldNode;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<E>, HoldNode<E>>(
-        graphPtr, std::forward<T>(initialValue), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
-}
+    { return Hold(evnt.GetGroup(), std::forward<T>(initialValue), evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Monitor - Emits value changes of target signal
@@ -62,28 +44,12 @@ template <typename S>
 auto Monitor(const Group& group, const Signal<S>& signal) -> Event<S>
 {
     using REACT_IMPL::MonitorNode;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
+    return Event<S>::CreateWithNode<MonitorNode<S>>(group, SameGroupOrLink(group, signal));
 }
 
 template <typename S>
 auto Monitor(const Signal<S>& signal) -> Event<S>
-{
-    using REACT_IMPL::MonitorNode;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<S>, MonitorNode<S>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal));
-}
+    { return Monitor(signal.GetGroup(), signal); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
@@ -94,9 +60,6 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IterateByRefNode;
     using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -104,33 +67,12 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
         IterateNode<S, FuncType, E>,
         IterateByRefNode<S, FuncType, E>>::type;
 
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
-        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
+    return Signal<S>::CreateWithNode<IterNodeType>(group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename T, typename F, typename E>
 auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
-{
-    using REACT_IMPL::IterateNode;
-    using REACT_IMPL::IterateByRefNode;
-    using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
-
-    using FuncType = typename std::decay<F>::type;
-    using IterNodeType = typename std::conditional<
-        IsCallableWith<F,S,EventRange<E>,S>::value,
-        IterateNode<S, FuncType, E>,
-        IterateByRefNode<S, FuncType, E>>::type;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
-        graphPtr, std::forward<T>(initialValue), std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
-}
+    { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Synced
@@ -141,10 +83,6 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::SyncedIterateByRefNode;
     using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
 
     using FuncType = typename std::decay<F>::type;
     using IterNodeType = typename std::conditional<
@@ -152,35 +90,13 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
         SyncedIterateNode<S, FuncType, E, Us ...>,
         SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
 
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
-        graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
-        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...);
+    return Signal<S>::CreateWithNode<IterNodeType>(
+        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, signals) ...);
 }
 
 template <typename S, typename T, typename F, typename E, typename ... Us>
 auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
-{
-    using REACT_IMPL::SyncedIterateNode;
-    using REACT_IMPL::SyncedIterateByRefNode;
-    using REACT_IMPL::IsCallableWith;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    using FuncType = typename std::decay<F>::type;
-    using IterNodeType = typename std::conditional<
-        IsCallableWith<F, S, EventRange<E>, S, Us ...>::value,
-        SyncedIterateNode<S, FuncType, E, Us ...>,
-        SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(evnt);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, IterNodeType>(
-        graphPtr, std::forward<T>(initialValue), std::forward<F>(func),
-        PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signals) ...);
-}
+    { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, signals ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Snapshot - Sets signal value to value of other signal when event is received
@@ -189,30 +105,12 @@ template <typename S, typename E>
 auto Snapshot(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
+    return Signal<S>::CreateWithNode<SnapshotNode<S, E>>(group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename E>
 auto Snapshot(const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
-{
-    using REACT_IMPL::SnapshotNode;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
-
-    return PrivateNodeInterface::CreateNodeHelper<Signal<S>, SnapshotNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
-}
+    { return Snapshot(signal.GetGroup(), signal, evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Pulse - Emits value of target signal when event is received
@@ -221,31 +119,12 @@ template <typename S, typename E>
 auto Pulse(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
 {
     using REACT_IMPL::PulseNode;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
+    return Event<S>::CreateWithNode<PulseNode<S, E>>(group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename E>
 auto Pulse(const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
-{
-    using REACT_IMPL::PulseNode;
-    using REACT_IMPL::PrivateSignalLinkNodeInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;;
-    using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(signal);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<S>, PulseNode<S, E>>(
-        graphPtr, PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, signal), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, evnt));
-}
+    { return Pulse(signal.GetGroup(), signal, evnt); }
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/Event.h b/include/react/Event.h
index d0dec01b..e4d2a987 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -21,7 +21,48 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-struct PrivateEventLinkNodeInterface;
+template <typename E>
+class EventInternals
+{
+protected:
+    using NodeType = EventStreamNode<E>;
+    using StorageType = typename NodeType::StorageType;
+
+public:
+    EventInternals(const EventInternals&) = default;
+    EventInternals& operator=(const EventInternals&) = default;
+
+    EventInternals(EventInternals&&) = default;
+    EventInternals& operator=(EventInternals&&) = default;
+
+    EventInternals(std::shared_ptr<NodeType>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
+
+    auto GetNodePtr() -> std::shared_ptr<NodeType>&
+        { return nodePtr_; }
+
+    auto GetNodePtr() const -> const std::shared_ptr<NodeType>&
+        { return nodePtr_; }
+
+    NodeId GetNodeId() const
+        { return nodePtr_->GetNodeId(); }
+
+    StorageType& Events()
+        { return nodePtr->Events(); }
+
+    const StorageType& Events() const
+        { return nodePtr->Events(); }
+
+    void SetPendingSuccessorCount(size_t count)
+        { nodePtr_->SetPendingSuccessorCount(count); }
+
+    void DecrementPendingSuccessorCount()
+        { nodePtr_->DecrementPendingSuccessorCount(); }
+
+private:
+    std::shared_ptr<NodeType> nodePtr_;
+};
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
@@ -31,11 +72,8 @@ struct PrivateEventLinkNodeInterface;
 /// Event
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class Event
+class Event : protected REACT_IMPL::EventInternals<E>
 {
-private:
-    using NodeType = REACT_IMPL::EventStreamNode<E>;
-
 public:
     Event(const Event&) = default;
     Event& operator=(const Event&) = default;
@@ -45,7 +83,7 @@ class Event
 
     template <typename F, typename T>
     Event(F&& func, const Event<T>& dep) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(std::forward<F>(func), dep) )
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(dep.GetGroup(), std::forward<F>(func), dep) )
         { }
 
     template <typename F, typename T>
@@ -55,7 +93,7 @@ class Event
 
     template <typename F, typename T, typename ... Us>
     Event(F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(std::forward<F>(func), dep, signals ...) )
+        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, signals ...) )
         { }
 
     template <typename F, typename T, typename ... Us>
@@ -78,44 +116,56 @@ class Event
     auto Transform(F&& pred) const -> decltype(auto)
         { return REACT::Transform(*this, std::forward<F>(f)); }*/
 
-protected:
-    // Internal node ctor
-    Event(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-        { }
+    auto GetGroup() const -> const Group&
+        { return GetNodePtr()->GetGroup(); }
 
-    auto NodePtr() -> std::shared_ptr<NodeType>&
-        { return nodePtr_; }
+    auto GetGroup() -> Group&
+        { return GetNodePtr()->GetGroup(); }
 
-    auto NodePtr() const -> const std::shared_ptr<NodeType>&
-        { return nodePtr_; }
+    friend bool operator==(const Event<E>& a, const Event<E>& b)
+        { return a.GetNodePtr() == b.GetNodePtr(); }
+
+    friend bool operator!=(const Event<E>& a, const Event<E>& b)
+        { return !(a == b); }
+
+    friend auto GetInternals(Event<E>& e) -> REACT_IMPL::EventInternals<E>&
+        { return e; }
+
+    friend auto GetInternals(const Event<E>& e) -> const REACT_IMPL::EventInternals<E>&
+        { return e; }
+
+public: // Internal
+    template <typename TNode, typename ... TArgs>
+    static Event<E> CreateWithNode(TArgs&& ... args)
+    {
+        return Event<E>( REACT_IMPL::CtorTag{ }, std::make_shared<TNode>(std::forward<TArgs>(args) ...) );
+    }
+
+protected:
+    // Private node ctor
+    Event(REACT_IMPL::CtorTag, std::shared_ptr<REACT_IMPL::EventStreamNode<E>>&& nodePtr) :
+        Event::EventInternals( std::move(nodePtr) )
+        { }
 
     template <typename F, typename T>
-    auto CreateProcessingNode(F&& func, const Event<T>& dep) -> decltype(auto)
+    auto CreateProcessingNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
-        using EventNodeType = REACT_IMPL::EventProcessingNode<E, T, typename std::decay<F>::type>;
+        using REACT_IMPL::EventProcessingNode;
+        using REACT_IMPL::SameGroupOrLink;
 
-        return std::make_shared<EventNodeType>(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), PrivateNodeInterface::NodePtr(dep));
+        return std::make_shared<EventProcessingNode<E, T, typename std::decay<F>::type>>(
+            group, std::forward<F>(func), SameGroupOrLink(group, dep));
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedProcessingNode(F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedProcessingNode(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
-        using REACT_IMPL::GetCheckedGraphPtr;
-        using REACT_IMPL::PrivateNodeInterface;
-        using EventNodeType = REACT_IMPL::SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>;
-
-        return std::make_shared<EventNodeType>(
-            GetCheckedGraphPtr(dep, syncs ...),
-            std::forward<F>(func),
-            PrivateNodeInterface::NodePtr(dep), PrivateNodeInterface::NodePtr(syncs) ...);
-    }
-
-private:
-    std::shared_ptr<NodeType> nodePtr_;
+        using REACT_IMPL::SyncedEventProcessingNode;
+        using REACT_IMPL::SameGroupOrLink;
 
-    friend struct REACT_IMPL::PrivateNodeInterface;
+        return std::make_shared<SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>>(
+            group, std::forward<F>(func), SameGroupOrLink(group, dep), SameGroupOrLink(group, syncs) ...);
+    }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -155,8 +205,8 @@ class EventSource : public Event<E>
 protected:
     auto CreateSourceNode(const Group& group) -> decltype(auto)
     {
-        using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
-        return std::make_shared<SrcNodeType>(group);
+        using REACT_IMPL::EventSourceNode;
+        return std::make_shared<EventSourceNode<E>>(group);
     }
 
 private:
@@ -167,10 +217,11 @@ class EventSource : public Event<E>
         using REACT_IMPL::ReactiveGraph;
         using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
 
-        SrcNodeType* castedPtr = static_cast<SrcNodeType*>(this->NodePtr().get());
+        SrcNodeType* castedPtr = static_cast<SrcNodeType*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetNodeId();
-        auto& graphPtr = NodePtr()->GraphPtr();
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
+
         graphPtr->AddInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<T>(value)); });
     }
 };
@@ -188,9 +239,14 @@ class EventSlot : public Event<E>
     EventSlot(EventSlot&&) = default;
     EventSlot& operator=(EventSlot&&) = default;
 
-    // Construct with value
+    // Construct with explicit group
     EventSlot(const Group& group, const Event<E>& input) :
-        EventSlot::EventSlotBase( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
+        EventSlot::Event( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
+        { }
+
+    // Construct with implicit group
+    EventSlot(const Event<E>& input) :
+        EventSlot::Event( REACT_IMPL::CtorTag{ }, CreateSlotNode(input.GetGroup(), input) )
         { }
 
     void Set(const Event<E>& newInput)
@@ -202,9 +258,8 @@ class EventSlot : public Event<E>
 protected:
     auto CreateSlotNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
-        using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
-
-        return std::make_shared<SlotNodeType>(group, input);
+        using REACT_IMPL::EventSlotNode;
+        return std::make_shared<EventSlotNode<E>>(group, SameGroupOrLink(input));
     }
 
 private:
@@ -237,27 +292,23 @@ class EventLink : public Event<E>
 
     // Construct with explicit group
     EventLink(const Group& group, const Event<E>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(group, input) )
+        EventLink::Event( REACT_IMPL::CtorTag{ }, CreateLinkNode(group, input) )
         { }
 
     // Construct with implicit group
     explicit EventLink(const Event<E>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        EventLink::Event( REACT_IMPL::CtorTag{ }, CreateLinkNode(input.GetGroup(), input) )
         { }
 
 protected:
     static auto CreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateGroupInterface;
-        using EventNodeType = REACT_IMPL::EventLinkNode<E>;
+        using REACT_IMPL::EventLinkNode;
 
-        auto node = std::make_shared<EventNodeType>(group, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
-        node->SetWeakSelfPtr(std::weak_ptr<EventNodeType>{ node });
+        auto node = std::make_shared<EventLinkNode<E>>(group, input);
+        node->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ node });
         return node;
     }
-
-    friend struct REACT_IMPL::PrivateEventLinkNodeInterface;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -267,9 +318,7 @@ template <typename T = void, typename U1, typename ... Us>
 auto Merge(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 {
     using REACT_IMPL::EventMergeNode;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateNodeInterface;
+    using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CtorTag;
 
     static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
@@ -280,33 +329,12 @@ auto Merge(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps)
         typename std::common_type<U1, Us ...>::type,
         T>::type;
 
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-    
-    return PrivateNodeInterface::CreateNodeHelper<Event<E>, EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
+    return Event<E>::CreateWithNode<EventMergeNode<E, U1, Us ...>>(group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
 }
 
 template <typename T = void, typename U1, typename ... Us>
 auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
-{
-    using REACT_IMPL::EventMergeNode;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-    using REACT_IMPL::CtorTag;
-
-    static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
-
-    // If supplied, use merge type, otherwise default to common type.
-    using E = typename std::conditional<
-        std::is_same<T, void>::value,
-        typename std::common_type<U1, Us ...>::type,
-        T>::type;
-
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<E>, EventMergeNode<E, U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
-}
+    { return Merge(dep1.GetGroup(), dep1, deps ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter
@@ -322,12 +350,7 @@ auto Filter(const Group& group, F&& pred, const Event<E>& dep) -> Event<E>
 
 template <typename F, typename E>
 auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
-{
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
-        { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
-
-    return Event<E>(std::move(filterFunc), dep);
-}
+    { return Filter(dep.GetGroup(), std::forward<F>(pred), dep); }
 
 template <typename F, typename E, typename ... Ts>
 auto Filter(const Group& group, F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
@@ -344,16 +367,7 @@ auto Filter(const Group& group, F&& pred, const Event<E>& dep, const Signal<Ts>&
 
 template <typename F, typename E, typename ... Ts>
 auto Filter(F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
-{
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
-    {
-        for (const auto& v : inRange)
-            if (capturedPred(v, values ...))
-                *out++ = v;
-    };
-
-    return Event<E>(std::move(filterFunc), dep, signals ...);
-}
+    { return Filter(dep.GetGroup(), std::forward<F>(pred), dep); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Transform
@@ -369,12 +383,7 @@ auto Transform(const Group& group, F&& op, const Event<T>& dep) -> Event<E>
 
 template <typename E, typename F, typename T>
 auto Transform(F&& op, const Event<T>& dep) -> Event<E>
-{
-    auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
-        { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
-
-    return Event<E>(std::move(transformFunc), dep);
-}
+    { return Transform(dep1.GetGroup(), std::forward<F>(op), dep); }
 
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
@@ -390,15 +399,7 @@ auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>
 
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
-{
-    auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
-    {
-        for (const auto& v : inRange)
-            *out++ = capturedPred(v, values ...);
-    };
-
-    return Event<E>(std::move(transformFunc), dep, signals ...);
-}
+    { return Transform(dep.GetGroup(), std::forward<F>(op), dep, signals ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
@@ -418,34 +419,16 @@ template <typename U1, typename ... Us>
 auto Join(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
-    using REACT_IMPL::PrivateGroupInterface;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateNodeInterface;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
 
-    // If supplied, use merge type, otherwise default to common type.
-    const auto& graphPtr = PrivateGroupInterface::GraphPtr(group);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
+    return Event<std::tuple<U1, Us ...>>::CreateWithNode<EventJoinNode<U1, Us ...>>(
+        group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
 }
 
 template <typename U1, typename ... Us>
 auto Join(const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
-{
-    using REACT_IMPL::EventJoinNode;
-    using REACT_IMPL::PrivateEventLinkNodeInterface;
-    using REACT_IMPL::PrivateNodeInterface;
-
-    static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
-
-    // If supplied, use merge type, otherwise default to common type.
-    const auto& graphPtr = PrivateNodeInterface::GraphPtr(dep1);
-
-    return PrivateNodeInterface::CreateNodeHelper<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(
-        graphPtr, PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
-}
+    { return Join(dep1.GetGroup(), dep1, deps ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Token
@@ -474,23 +457,14 @@ bool Equals(const Event<L>& lhs, const Event<R>& rhs)
     return lhs.Equals(rhs);
 }
 
-struct PrivateEventLinkNodeInterface
+template <typename E>
+static Event<E> SameGroupOrLink(const Group& targetGroup, const Event<E>& dep)
 {
-    template <typename E>
-    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const Event<E>& dep) -> std::shared_ptr<EventStreamNode<E>>
-    {
-        const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(dep);
-
-        if (sourceGraph == targetGraph)
-        {
-            return PrivateNodeInterface::NodePtr(dep);
-        }
-        else
-        {
-            return EventLink<E>::CreateLinkNode(targetGraph, dep);
-        }
-    }
-};
+    if (dep.GetGroup() == targetGroup)
+        return dep;
+    else
+        return EventLink<E>( targetGroup, dep );
+}
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
diff --git a/include/react/Group.h b/include/react/Group.h
index 6e9a645d..d68526df 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -21,8 +21,33 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-struct PrivateGroupInterface;
-struct CtorTag { };
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// GroupInternals
+///////////////////////////////////////////////////////////////////////////////////////////////////
+class GroupInternals
+{
+    using GraphType = REACT_IMPL::ReactiveGraph;
+
+public:
+    GroupInternals() :
+        graphPtr_( std::make_shared<GraphType>() )
+        {  }
+
+    GroupInternals(const GroupInternals&) = default;
+    GroupInternals& operator=(const GroupInternals&) = default;
+
+    GroupInternals(GroupInternals&&) = default;
+    GroupInternals& operator=(GroupInternals&&) = default;
+
+    auto GetGraphPtr() -> std::shared_ptr<GraphType>&
+        { return graphPtr_; }
+
+    auto GetGraphPtr() const -> const std::shared_ptr<GraphType>&
+        { return graphPtr_; }
+
+private:
+    std::shared_ptr<GraphType> graphPtr_;
+};
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
@@ -85,26 +110,22 @@ class TransactionStatus
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// GroupBase
+/// Group
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class Group
+class Group : protected REACT_IMPL::GroupInternals
 {
-    using GraphType = REACT_IMPL::ReactiveGraph;
-
 public:
-    Group() :
-        graphPtr_( std::make_shared<GraphType>() )
-        {  }
+    Group() = default;
 
     Group(const Group&) = default;
     Group& operator=(const Group&) = default;
 
-    Group(Group&& other) = default;
-    Group& operator=(Group&& other) = default;
+    Group(Group&&) = default;
+    Group& operator=(Group&&) = default;
 
     template <typename F>
     void DoTransaction(F&& func)
-        { graphPtr_->DoTransaction(std::forward<F>(func)); }
+        { GetGraphPtr()->DoTransaction(std::forward<F>(func)); }
 
     template <typename F>
     void EnqueueTransaction(F&& func)
@@ -112,18 +133,19 @@ class Group
 
     template <typename F>
     void EnqueueTransaction(TransactionFlags flags, F&& func)
-        { graphPtr_->EnqueueTransaction(flags, std::forward<F>(func)); }
+        { GetGraphPtr()->EnqueueTransaction(flags, std::forward<F>(func)); }
 
+    friend bool operator==(const Group& a, const Group& b)
+        { return a.GetGraphPtr() == b.GetGraphPtr(); }
 
-public: // Internal
-    auto GraphPtr() -> std::shared_ptr<GraphType>&
-        { return graphPtr_; }
+    friend bool operator!=(const Group& a, const Group& b)
+        { return !(a == b); }
 
-    auto GraphPtr() const -> const std::shared_ptr<GraphType>&
-        { return graphPtr_; }
+    friend auto GetInternals(Group& g) -> REACT_IMPL::GroupInternals&
+        { return g; }
 
-private:
-    std::shared_ptr<GraphType> graphPtr_;
+    friend auto GetInternals(const Group& g) -> const REACT_IMPL::GroupInternals&
+        { return g; }
 };
 
 /******************************************/ REACT_END /******************************************/
diff --git a/include/react/Observer.h b/include/react/Observer.h
index b0b64c8e..a2ff497a 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -35,22 +35,16 @@ class Observer
     Observer(Observer&&) = default;
     Observer& operator=(Observer&&) = default;
 
-    // Construct signal observer with implicit group
-    template <typename F, typename ... Ts>
-    Observer(F&& func, const Signal<Ts>& ... subjects) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(std::forward<F>(func), subjects ...))
-        { }
-
     // Construct signal observer with explicit group
-    template <typename F, typename ... Ts>
-    Observer(const Group& group, F&& func, const Signal<Ts>& ... subjects) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(group, std::forward<F>(func), subjects ...))
+    template <typename F, typename T1, typename ... Ts>
+    Observer(const Group& group, F&& func, const Signal<T1>& subject1, const Signal<Ts>& ... subjects) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(group, std::forward<F>(func), subject1, subjects ...))
         { }
 
-    // Construct event observer with implicit group
-    template <typename F, typename T>
-    Observer(F&& func, const Event<T>& subject) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(std::forward<F>(func), subject))
+    // Construct signal observer with implicit group
+    template <typename F, typename T1, typename ... Ts>
+    Observer(F&& func, const Signal<T1>& subject1, const Signal<Ts>& ... subjects) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...))
         { }
 
     // Construct event observer with explicit group
@@ -59,10 +53,10 @@ class Observer
         Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(group, std::forward<F>(func), subject))
         { }
 
-    // Constructed synced event observer with implicit group
-    template <typename F, typename T, typename ... Us>
-    Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(std::forward<F>(func), subject, signals ...))
+    // Construct event observer with implicit group
+    template <typename F, typename T>
+    Observer(F&& func, const Event<T>& subject) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject))
         { }
 
     // Constructed synced event observer with explicit group
@@ -71,6 +65,12 @@ class Observer
         Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, signals ...))
         { }
 
+    // Constructed synced event observer with implicit group
+    template <typename F, typename T, typename ... Us>
+    Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
+        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, signals ...))
+        { }
+
 public: //Internal
     // Private node ctor
     Observer(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
@@ -87,55 +87,29 @@ class Observer
     template <typename F, typename T1, typename ... Ts>
     auto CreateSignalObserverNode(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateSignalLinkNodeInterface;
-        using ObsNodeType = REACT_IMPL::SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>;
-
-        return std::make_shared<ObsNodeType>(
-            group,
-            std::forward<F>(func),
-            PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
-    }
-
-    template <typename F, typename T1, typename ... Ts>
-    auto CreateSignalObserverNode(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
-    {
-        return CreateSignalObserverNode(PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...);
+        using REACT_IMPL::SignalObserverNode;
+        return std::make_shared<SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>>(
+            group, std::forward<F>(func), SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
     }
 
     template <typename F, typename T>
     auto CreateEventObserverNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateEventLinkNodeInterface;
-        using ObsNodeType = REACT_IMPL::EventObserverNode<typename std::decay<F>::type, T>;
-
-        return std::make_shared<ObsNodeType>(group, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep));
-    }
-
-    template <typename F, typename T>
-    auto CreateEventObserverNode(F&& func, const Event<T>& dep) -> decltype(auto)
-    {
-        return CreateEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep);
+        using REACT_IMPL::EventObserverNode;
+        return std::make_shared<EventObserverNode<typename std::decay<F>::type, T>>(
+            group, std::forward<F>(func), SameGroupOrLink(group, dep));
     }
 
     template <typename F, typename T, typename ... Us>
     auto CreateSyncedEventObserverNode(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateEventLinkNodeInterface;
-        using REACT_IMPL::PrivateSignalLinkNodeInterface;
-        using ObsNodeType = REACT_IMPL::SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>;
-
-        return std::make_shared<ObsNodeType>(
-            graphPtr, std::forward<F>(func), PrivateEventLinkNodeInterface::GetLocalNodePtr(graphPtr, dep), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, syncs) ...);
-    }
-
-    template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
-    {
-        return CreateSyncedEventObserverNode(PrivateNodeInterface::GraphPtr(dep), std::forward<F>(func), dep, syncs ...);
+        using REACT_IMPL::SyncedEventObserverNode;
+        return std::make_shared<SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>>(
+            group, std::forward<F>(func), SameGroupOrLink(group, dep), SameGroupOrLink(group, syncs) ...);
     }
 
 private:
-    std::shared_ptr<NodeType> nodePtr_;s
+    std::shared_ptr<NodeType> nodePtr_;
 };
 
 /******************************************/ REACT_END /******************************************/
diff --git a/include/react/Signal.h b/include/react/Signal.h
index bc607a9f..58e5da37 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -9,10 +9,6 @@
 
 #pragma once
 
-#if _MSC_VER && !__INTEL_COMPILER
-    #pragma warning(disable : 4503)
-#endif
-
 #include "react/detail/Defs.h"
 #include "react/API.h"
 #include "react/Group.h"
@@ -26,7 +22,38 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-struct PrivateSignalLinkNodeInterface;
+template <typename S>
+class SignalInternals
+{
+public:
+    SignalInternals(const SignalInternals&) = default;
+    SignalInternals& operator=(const SignalInternals&) = default;
+
+    SignalInternals(SignalInternals&&) = default;
+    SignalInternals& operator=(SignalInternals&&) = default;
+
+    SignalInternals(std::shared_ptr<SignalNode<S>>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+        { }
+
+    auto GetNodePtr() -> std::shared_ptr<SignalNode<S>>&
+        { return nodePtr_; }
+
+    auto GetNodePtr() const -> const std::shared_ptr<SignalNode<S>>&
+        { return nodePtr_; }
+
+    NodeId GetNodeId() const
+        { return nodePtr_->GetNodeId(); }
+
+    S& Value()
+        { return nodePtr_->Value(); }
+
+    const S& Value() const
+        { return nodePtr_->Value(); }
+
+private:
+    std::shared_ptr<SignalNode<S>> nodePtr_;
+};
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
@@ -36,11 +63,8 @@ struct PrivateSignalLinkNodeInterface;
 /// Signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class Signal
+class Signal : protected REACT_IMPL::SignalInternals<S>
 {
-private:
-    using NodeType = REACT_IMPL::SignalNode<S>;
-
 public:
     Signal(const Signal&) = default;
     Signal& operator=(const Signal&) = default;
@@ -48,48 +72,53 @@ class Signal
     Signal(Signal&&) = default;
     Signal& operator=(Signal&&) = default;
 
-    // Construct func signal with explicit group
+    // Construct with explicit group
     template <typename F, typename T1, typename ... Ts>
     explicit Signal(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
-        Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), std::forward<F>(func), dep1, deps ...) )
+        Signal::SignalInternals( CreateFuncNode(group, std::forward<F>(func), dep1, deps ...) )
         { }
 
-    // Construct func signal with implicit group
+    // Construct with implicit group
     template <typename F, typename T1, typename ... Ts>
     explicit Signal(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
-        Signal::Signal( REACT_IMPL::CtorTag{ }, CreateFuncNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(dep1), std::forward<F>(func), dep1, deps ...) )
+        Signal::SignalInternals( CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...) )
         { }
 
-    const Group& GetGroup() const
-        { return nodePtr_->GetGroup(); }
+    auto GetGroup() const -> const Group&
+        { return this->GetNodePtr()->GetGroup(); }
 
-public: // Internal
-    // Private node ctor
-    Signal(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-        { }
+    auto GetGroup() -> Group&
+        { return this->GetNodePtr()->GetGroup(); }
 
-    auto NodePtr() -> std::shared_ptr<NodeType>&
-        { return nodePtr_; }
+    friend bool operator==(const Signal<S>& a, const Signal<S>& b)
+        { return a.GetNodePtr() == b.GetNodePtr(); }
 
-    auto NodePtr() const -> const std::shared_ptr<NodeType>&
-        { return nodePtr_; }
+    friend bool operator!=(const Signal<S>& a, const Signal<S>& b)
+        { return !(a == b); }
+
+    friend auto GetInternals(Signal<S>& s) -> REACT_IMPL::SignalInternals<S>&
+        { return s; }
+
+    friend auto GetInternals(const Signal<S>& s) -> const REACT_IMPL::SignalInternals<S>&
+        { return s; }
+
+    template <typename TNode, typename ... TArgs>
+    static Signal<S> CreateWithNode(TArgs&& ... args)
+        { return Signal<S>( REACT_IMPL::CtorTag{ }, std::make_shared<TNode>(std::forward<TArgs>(args) ...) ); }
 
 protected:
+    Signal(REACT_IMPL::CtorTag, std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
+        Signal::SignalInternals( std::move(nodePtr) )
+        { }
+
     template <typename F, typename T1, typename ... Ts>
-    auto CreateFuncNode(const std::shared_ptr<REACT_IMPL::ReactiveGraph>& graphPtr, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
+    auto CreateFuncNode(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateSignalLinkNodeInterface;
-        using FuncNodeType = REACT_IMPL::SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>;
+        using REACT_IMPL::SignalFuncNode;
 
-        return std::make_shared<FuncNodeType>(
-            graphPtr,
-            std::forward<F>(func),
-            PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, dep1), PrivateSignalLinkNodeInterface::GetLocalNodePtr(graphPtr, deps) ...);
+        return std::make_shared<SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>>(
+            group, std::forward<F>(func), SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
     }
-
-private:
-    std::shared_ptr<NodeType> nodePtr_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -132,18 +161,24 @@ class VarSignal : public Signal<S>
     void Modify(const F& func)
         { ModifyValue(func); }
 
+    friend bool operator==(const VarSignal<S>& a, VarSignal<S>& b)
+        { return a.GetNodePtr() == b.GetNodePtr(); }
+
+    friend bool operator!=(const VarSignal<S>& a, VarSignal<S>& b)
+        { return !(a == b); }
+
 protected:
     static auto CreateVarNode(const Group& group) -> decltype(auto)
     {
-        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
-        return std::make_shared<VarNodeType>(graphPtr);
+        using REACT_IMPL::VarSignalNode;
+        return std::make_shared<VarSignalNode<S>>(group);
     }
 
     template <typename T>
     static auto CreateVarNode(const Group& group, T&& value) -> decltype(auto)
     {
-        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
-        return std::make_shared<VarNodeType>(graphPtr, std::forward<T>(value));
+        using REACT_IMPL::VarSignalNode;
+        return std::make_shared<VarSignalNode<S>>(group, std::forward<T>(value));
     }
 
 private:
@@ -153,10 +188,11 @@ class VarSignal : public Signal<S>
         using REACT_IMPL::NodeId;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
-        VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
+        VarNodeType* castedPtr = static_cast<VarNodeType*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetNodeId();
-        auto& graphPtr = NodePtr()->GraphPtr();
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
+
         graphPtr->AddInput(nodeId, [castedPtr, &newValue] { castedPtr->SetValue(std::forward<T>(newValue)); });
     }
 
@@ -166,10 +202,11 @@ class VarSignal : public Signal<S>
         using REACT_IMPL::NodeId;
         using VarNodeType = REACT_IMPL::VarSignalNode<S>;
 
-        VarNodeType* castedPtr = static_cast<VarNodeType*>(this->NodePtr().get());
+        VarNodeType* castedPtr = static_cast<VarNodeType*>(this->GetNodePtr().get());
         
         NodeId nodeId = castedPtr->GetNodeId();
-        auto& graphPtr = castedPtr->GraphPtr();
+        auto& graphPtr = BaseCast(this->GetGroup()).GetGraphPtr();
+
         graphPtr->AddInput(nodeId, [castedPtr, &func] { castedPtr->ModifyValue(func); });
     }
 };
@@ -189,17 +226,17 @@ class SignalSlot : public Signal<S>
 
     // Construct with group + default
     explicit SignalSlot(const Group& group) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group)) )
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(group) )
         { }
 
     // Construct with group + value
     SignalSlot(const Group& group, const Signal<S>& input) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateGroupInterface::GraphPtr(group), input) )
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
         { }
 
     // Construct with value
     explicit SignalSlot(const Signal<S>& input) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(REACT_IMPL::PrivateNodeInterface::GraphPtr(input), input) )
+        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(input.GetGroup(), input) )
         { }
 
     void Set(const Signal<S>& newInput)
@@ -209,26 +246,30 @@ class SignalSlot : public Signal<S>
         { SetInput(newInput); }
 
 protected:
-    static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
+    static auto CreateSlotNode(const Group& group) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
-        using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
+        using REACT_IMPL::SignalSlotNode;
+        return std::make_shared<SignalSlotNode<S>>(group);
+    }
 
-        return std::make_shared<SlotNodeType>(graphPtr, PrivateNodeInterface::NodePtr(input));
+    static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
+    {
+        using REACT_IMPL::SignalSlotNode;
+        return std::make_shared<SignalSlotNode<S>>(group, input);
     }
 
 private:
     void SetInput(const Signal<S>& newInput)
     {
-        using REACT_IMPL::PrivateNodeInterface;
         using REACT_IMPL::NodeId;
         using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
 
-        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->NodePtr().get());
+        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetInputNodeId();
-        auto& graphPtr = NodePtr()->GraphPtr();
-        graphPtr->AddInput(nodeId, [castedPtr, &newInput] { castedPtr->SetInput(PrivateNodeInterface::NodePtr(newInput)); });
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
+
+        graphPtr->AddInput(nodeId, [castedPtr, &newInput] { castedPtr->SetInput(newInput); });
     }
 };
 
@@ -258,16 +299,12 @@ class SignalLink : public Signal<S>
 protected:
     static auto CreateLinkNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
-        using REACT_IMPL::PrivateNodeInterface;
-        using REACT_IMPL::PrivateGroupInterface;
-        using LinkNodeType = REACT_IMPL::SignalLinkNode<S>;
+        using REACT_IMPL::SignalLinkNode;
 
-        auto node = std::make_shared<LinkNodeType>(graphPtr, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
-        node->SetWeakSelfPtr(std::weak_ptr<LinkNodeType>{ node });
+        auto node = std::make_shared<SignalLinkNode<S>>(group, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
+        node->SetWeakSelfPtr(std::weak_ptr<SignalLinkNode<S>>{ node });
         return node;
     }
-
-    friend struct REACT_IMPL::PrivateSignalLinkNodeInterface;
 };
 
 /******************************************/ REACT_END /******************************************/
@@ -280,61 +317,15 @@ bool Equals(const Signal<L>& lhs, const Signal<R>& rhs)
     return lhs.Equals(rhs);
 }
 
-struct PrivateSignalLinkNodeInterface
+template <typename S>
+static Signal<S> SameGroupOrLink(const Group& targetGroup, const Signal<S>& dep)
 {
-    template <typename S>
-    static auto GetLocalNodePtr(const std::shared_ptr<ReactiveGraph>& targetGraph, const Signal<S>& sig) -> std::shared_ptr<SignalNode<S>>
-    {
-        const std::shared_ptr<ReactiveGraph>& sourceGraph = PrivateNodeInterface::GraphPtr(sig);
-
-        if (sourceGraph == targetGraph)
-        {
-            return PrivateNodeInterface::NodePtr(sig);
-        }
-        else
-        {
-            return SignalLink<S>::CreateLinkNode(targetGraph, sig);
-        }
-    }
-};
+    if (dep.GetGroup() == targetGroup)
+        return dep;
+    else
+        return SignalLink<S>( group, dep );
+}
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten macros
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Note: Using static_cast rather than -> return type, because when using lambda for inline
-// class initialization, decltype did not recognize the parameter r
-// Note2: MSVC doesn't like typename in the lambda
-#if _MSC_VER && !__INTEL_COMPILER
-    #define REACT_MSVC_NO_TYPENAME
-#else
-    #define REACT_MSVC_NO_TYPENAME typename
-#endif
-
-#define REACTIVE_REF(obj, name)                                                             \
-    Flatten(                                                                                \
-        MakeSignal(                                                                         \
-            obj,                                                                            \
-            [] (const REACT_MSVC_NO_TYPENAME                                                \
-                REACT_IMPL::Identity<decltype(obj)>::Type::ValueT& r)                       \
-            {                                                                               \
-                using T = decltype(r.name);                                                 \
-                using S = REACT_MSVC_NO_TYPENAME REACT::DecayInput<T>::Type;                \
-                return static_cast<S>(r.name);                                              \
-            }))
-
-#define REACTIVE_PTR(obj, name)                                                             \
-    Flatten(                                                                                \
-        MakeSignal(                                                                         \
-            obj,                                                                            \
-            [] (REACT_MSVC_NO_TYPENAME                                                      \
-                REACT_IMPL::Identity<decltype(obj)>::Type::ValueT r)                        \
-            {                                                                               \
-                assert(r != nullptr);                                                       \
-                using T = decltype(r->name);                                                \
-                using S = REACT_MSVC_NO_TYPENAME REACT::DecayInput<T>::Type;                \
-                return static_cast<S>(r->name);                                             \
-            }))
-
 #endif // REACT_SIGNAL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/Defs.h b/include/react/detail/Defs.h
index 24f4cd97..6bdda2e0 100644
--- a/include/react/detail/Defs.h
+++ b/include/react/detail/Defs.h
@@ -21,22 +21,6 @@
 #define REACT_IMPL_END      REACT_END       }
 #define REACT_IMPL          REACT           ::impl
 
-// Assert with message
-#define REACT_ASSERT(condition, ...) for (; !(condition); assert(condition)) printf(__VA_ARGS__)
-#define REACT_ERROR(...)    REACT_ASSERT(false, __VA_ARGS__)
-
-// Thread local storage
-#if _WIN32 || _WIN64
-    // MSVC
-    #define REACT_TLS   __declspec(thread)
-#elif __GNUC__
-    // GCC
-    #define REACT_TLS   __thread    
-#else
-    // Standard C++11
-    #define REACT_TLS   thread_local
-#endif
-
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 // Type aliases
@@ -44,6 +28,8 @@ using uint = unsigned int;
 using uchar = unsigned char;
 using std::size_t;
 
+struct CtorTag { };
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_DEFS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 274581fd..0287a816 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -86,8 +86,8 @@ class IterateNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    IterateNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
-        IterateNode::SignalNode( graphPtr, std::forward<T>(init) ),
+    IterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& events) :
+        IterateNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events )
     {
@@ -125,7 +125,7 @@ class IterateNode : public SignalNode<S>
         { return 1; }
 
 private:
-    std::shared_ptr<EventStreamNode<E>> events_;
+    Event<E> events_;
     
     F func_;
 };
@@ -138,8 +138,8 @@ class IterateByRefNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    IterateByRefNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events) :
-        IterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
+    IterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& events) :
+        IterateByRefNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events )
     {
@@ -172,7 +172,7 @@ class IterateByRefNode : public SignalNode<S>
 protected:
     F   func_;
 
-    std::shared_ptr<EventStreamNode<E>> events_;
+    Event<E> events_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -183,8 +183,8 @@ class SyncedIterateNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedIterateNode::SignalNode( graphPtr, std::forward<T>(init) ),
+    SyncedIterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& events, const Signal<TSyncs>& ... syncs) :
+        SyncedIterateNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events ),
         syncHolder_( syncs ... )
@@ -236,7 +236,7 @@ class SyncedIterateNode : public SignalNode<S>
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<E>> events_;
+    Event<E> events_;
 
     std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
 };
@@ -249,8 +249,8 @@ class SyncedIterateByRefNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateByRefNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& events, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedIterateByRefNode::SignalNode( graphPtr, std::forward<T>(init) ),
+    SyncedIterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& events, const Signal<TSyncs>& ... syncs) :
+        SyncedIterateByRefNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         events_( events ),
         syncHolder_( syncs ... )
@@ -294,9 +294,9 @@ class SyncedIterateByRefNode : public SignalNode<S>
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<E>> events_;
+    Event<E> events_;
 
-    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
+    std::tuple<Signal<TSyncs> ...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -307,8 +307,8 @@ class HoldNode : public SignalNode<S>
 {
 public:
     template <typename T>
-    HoldNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& init, const std::shared_ptr<EventStreamNode<S>>& events) :
-        HoldNode::SignalNode( graphPtr, std::forward<T>(init) ),
+    HoldNode(const Group& group, T&& init, const Event<S>& events) :
+        HoldNode::SignalNode( group, std::forward<T>(init) ),
         events_( events )
     {
         this->RegisterMe();
@@ -351,7 +351,7 @@ class HoldNode : public SignalNode<S>
         { return 1; }
 
 private:
-    const std::shared_ptr<EventStreamNode<S>>    events_;
+    const Event<S>    events_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -361,8 +361,8 @@ template <typename S, typename E>
 class SnapshotNode : public SignalNode<S>
 {
 public:
-    SnapshotNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
-        SnapshotNode::SignalNode( graphPtr, target->Value() ),
+    SnapshotNode(const Group& group, const Signal<S>& target, const Event<E>& trigger) :
+        SnapshotNode::SignalNode( group, target->Value() ),
         target_( target ),
         trigger_( trigger )
     {
@@ -408,8 +408,8 @@ class SnapshotNode : public SignalNode<S>
         { return 2; }
 
 private:
-    std::shared_ptr<SignalNode<S>>      target_;
-    std::shared_ptr<EventStreamNode<E>> trigger_;
+    Signal<S>   target_;
+    Event<E>    trigger_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -419,8 +419,8 @@ template <typename S>
 class MonitorNode : public EventStreamNode<S>
 {
 public:
-    MonitorNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target) :
-        MonitorNode::EventStreamNode( graphPtr ),
+    MonitorNode(const Group& group, const Signal<S>& target) :
+        MonitorNode::EventStreamNode( group ),
         target_( target )
     {
         this->RegisterMe();
@@ -449,7 +449,7 @@ class MonitorNode : public EventStreamNode<S>
         { return 1; }
 
 private:
-    std::shared_ptr<SignalNode<S>>    target_;
+    Signal<S>    target_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -459,8 +459,8 @@ template <typename S, typename E>
 class PulseNode : public EventStreamNode<S>
 {
 public:
-    PulseNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& target, const std::shared_ptr<EventStreamNode<E>>& trigger) :
-        PulseNode::EventStreamNode( graphPtr ),
+    PulseNode(const Group& group, const Signal<S>& target, const Event<E>& trigger) :
+        PulseNode::EventStreamNode( group ),
         target_( target ),
         trigger_( trigger )
     {
@@ -501,8 +501,8 @@ class PulseNode : public EventStreamNode<S>
         { return 2; }
 
 private:
-    const std::shared_ptr<SignalNode<S>>      target_;
-    const std::shared_ptr<EventStreamNode<E>> trigger_;
+    Signal<S>   target_;
+    Event<E>    trigger_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 374038fb..c8d91af0 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -87,8 +87,8 @@ class EventStreamNode : public NodeBase
     EventStreamNode(const EventStreamNode&) = delete;
     EventStreamNode& operator=(const EventStreamNode&) = delete;
 
-    explicit EventStreamNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
-        NodeBase( graphPtr )
+    explicit EventStreamNode(const Group& group) :
+        NodeBase( group )
         { }
 
     StorageType& Events()
@@ -122,7 +122,7 @@ class EventStreamNode : public NodeBase
         // Last successor to arrive clears the buffer.
         if (pendingSuccessorCount_-- == 1)
             events_.clear();
-    };
+    }
 
 private:
     StorageType events_;
@@ -137,12 +137,16 @@ template <typename T>
 class EventSourceNode : public EventStreamNode<T>
 {
 public:
-    EventSourceNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
-        EventSourceNode::EventStreamNode( graphPtr )
-        { this->RegisterMe(NodeCategory::input); }
+    EventSourceNode(const Group& group) :
+        EventSourceNode::EventStreamNode( group )
+    {
+        this->RegisterMe(NodeCategory::input);
+    }
 
     ~EventSourceNode()
-        { this->UnregisterMe(); }
+    {
+        this->UnregisterMe();
+    }
 
     virtual const char* GetNodeType() const override
         { return "EventSource"; }
@@ -175,8 +179,8 @@ template <typename TOut, typename ... TIns>
 class EventMergeNode : public EventStreamNode<TOut>
 {
 public:
-    EventMergeNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<TIns>>& ... deps) :
-        EventMergeNode::EventStreamNode( graphPtr ),
+    EventMergeNode(const Group& group, const Event<TIns>& ... deps) :
+        EventMergeNode::EventStreamNode( group ),
         depHolder_( deps ... )
     {
         this->RegisterMe();
@@ -185,7 +189,7 @@ class EventMergeNode : public EventStreamNode<TOut>
 
     ~EventMergeNode()
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(deps->GetNodeId())); }, depHolder_);
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
@@ -212,13 +216,15 @@ class EventMergeNode : public EventStreamNode<TOut>
 
 private:
     template <typename U>
-    void MergeFromDep(const std::shared_ptr<EventStreamNode<U>>& other)
+    void MergeFromDep(const Event<U>& dep)
     {
-        this->Events().insert(this->Events().end(), other->Events().begin(), other->Events().end());
-        other->DecrementPendingSuccessorCount();
+        auto& depNodePtr = BaseCast(dep).GetNodePtr();
+
+        this->Events().insert(this->Events().end(), depNodePtr->Events().begin(), depNodePtr->Events().end());
+        depNodePtr->DecrementPendingSuccessorCount();
     }
 
-    std::tuple<std::shared_ptr<EventStreamNode<TIns>> ...> depHolder_;
+    std::tuple<Event<TIns> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -228,8 +234,8 @@ template <typename E>
 class EventSlotNode : public EventStreamNode<E>
 {
 public:
-    EventSlotNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<E>>& dep) :
-        EventSlotNode::EventStreamNode( graphPtr ),
+    EventSlotNode(const Group& group, const Event<E>& dep) :
+        EventSlotNode::EventStreamNode( group ),
         slotInput_( *this, dep )
     {
         slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
@@ -280,7 +286,7 @@ class EventSlotNode : public EventStreamNode<E>
 private:        
     struct VirtualInputNode : public IReactiveNode
     {
-        VirtualInputNode(EventSlotNode& parentIn, const std::shared_ptr<EventStreamNode<E>>& depIn) :
+        VirtualInputNode(EventSlotNode& parentIn, const Event<E>& depIn) :
             parent( parentIn ),
             dep( depIn )
             { }
@@ -312,8 +318,8 @@ class EventSlotNode : public EventStreamNode<E>
 
         NodeId nodeId;
 
-        std::shared_ptr<EventStreamNode<E>> dep;
-        std::shared_ptr<EventStreamNode<E>> newDep;
+        Event<E> dep;
+        Event<E> newDep;
     };
 
     VirtualInputNode slotInput_;
@@ -327,8 +333,8 @@ class EventProcessingNode : public EventStreamNode<TOut>
 {
 public:
     template <typename FIn>
-    EventProcessingNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep) :
-        EventProcessingNode::EventStreamNode( graphPtr ),
+    EventProcessingNode(const Group& group, FIn&& func, const Event<TIn>& dep) :
+        EventProcessingNode::EventStreamNode( group ),
         func_( std::forward<FIn>(func) ),
         dep_( dep )
     {
@@ -368,7 +374,7 @@ class EventProcessingNode : public EventStreamNode<TOut>
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<TIn>> dep_;
+    Event<TIn> dep_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -379,8 +385,8 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 {
 public:
     template <typename FIn>
-    SyncedEventProcessingNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<TIn>>& dep, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedEventProcessingNode::EventStreamNode( graphPtr ),
+    SyncedEventProcessingNode(const Group& group, FIn&& func, const Event<TIn>& dep, const Signal<TSyncs>& ... syncs) :
+        SyncedEventProcessingNode::EventStreamNode( group ),
         func_( std::forward<FIn>(func) ),
         dep_( dep ),
         syncHolder_( syncs ... )
@@ -432,9 +438,9 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<TIn>> dep_;
+    Event<TIn> dep_;
 
-    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
+    std::tuple<Signal<TSyncs> ...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -444,8 +450,8 @@ template <typename ... Ts>
 class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 {
 public:
-    EventJoinNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<EventStreamNode<Ts>>& ... deps) :
-        EventJoinNode::EventStreamNode( graphPtr ),
+    EventJoinNode(const Group& group, const Event<Ts>& ... deps) :
+        EventJoinNode::EventStreamNode( group ),
         slots_( deps ... )
     {
         this->RegisterMe();
@@ -510,12 +516,12 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     template <typename U>
     struct Slot
     {
-        Slot(const std::shared_ptr<EventStreamNode<U>>& src) :
+        Slot(const Event<U>& src) :
             source( src )
             { }
 
-        std::shared_ptr<EventStreamNode<U>>     source;
-        std::deque<U>                           buffer;
+        Event<U>        source;
+        std::deque<U>   buffer;
     };
 
     template <typename U>
@@ -542,9 +548,9 @@ template <typename E>
 class EventLinkNode : public EventStreamNode<E>
 {
 public:
-    EventLinkNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<ReactiveGraph>& srcGraphPtr, const std::shared_ptr<EventStreamNode<E>>& dep) :
-        EventLinkNode::EventStreamNode( graphPtr ),
-        linkOutput_( srcGraphPtr, dep )
+    EventLinkNode(const Group& group, const Event<E>& dep) :
+        EventLinkNode::EventStreamNode( group ),
+        linkOutput_( dep )
     {
         this->RegisterMe(NodeCategory::input);
     }
@@ -575,10 +581,10 @@ class EventLinkNode : public EventStreamNode<E>
 private:
     struct VirtualOutputNode : public ILinkOutputNode
     {
-        VirtualOutputNode(const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<EventStreamNode<E>>& depIn) :
+        VirtualOutputNode(const Event<E>& depIn) :
             parent( ),
-            srcGraphPtr( srcGraphPtrIn ),
-            dep( depIn )
+            dep( depIn ),
+            srcGroup( depIn.GetGroup() )
         {
             nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
             srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
@@ -597,9 +603,7 @@ class EventLinkNode : public EventStreamNode<E>
             { return 1; }
 
         virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
-        {            
-            return UpdateResult::changed;
-        }
+            { return UpdateResult::changed; }
 
         virtual void CollectOutput(LinkOutputMap& output) override
         {
@@ -623,11 +627,9 @@ class EventLinkNode : public EventStreamNode<E>
 
         std::weak_ptr<EventLinkNode> parent;
 
-        NodeId nodeId;
-
-        std::shared_ptr<EventStreamNode<E>> dep;
-
-        std::shared_ptr<ReactiveGraph> srcGraphPtr;
+        NodeId      nodeId;
+        Event<E>    dep;
+        Group       srcGroup;
     };
 
     VirtualOutputNode linkOutput_;
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 3305ca40..a3769ce3 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -58,33 +58,36 @@ class NodeBase : public IReactiveNode
     NodeId GetNodeId() const
         { return nodeId_; }
 
-    const Group& GetGroup() const
+    auto GetGroup() const -> const Group&
         { return group_; }
 
-    auto GraphPtr() const -> const std::shared_ptr<ReactiveGraph>&
-        { return GroupInternals::GraphPtr(group_); }
-
-    auto GraphPtr() -> std::shared_ptr<ReactiveGraph>&
-        { return GroupInternals::GraphPtr(group_); }
+    auto GetGroup() -> Group&
+        { return group_; }
 
 protected:
+    auto GetGraphPtr() const -> const std::shared_ptr<ReactiveGraph>&
+        { GetInternals(group_).GetGraphPtr(); }
+
+    auto GetGraphPtr() -> std::shared_ptr<ReactiveGraph>&
+        { GetInternals(group_).GetGraphPtr(); }
+
     void RegisterMe(NodeCategory category = NodeCategory::normal)
-        { nodeId_ = GraphPtr()->RegisterNode(this, category); }
+        { nodeId_ = GetGraphPtr()->RegisterNode(this, category); }
     
     void UnregisterMe()
-        { GraphPtr()->UnregisterNode(nodeId_); }
+        { GetGraphPtr()->UnregisterNode(nodeId_); }
 
     void AttachToMe(NodeId otherNodeId)
-        { GraphPtr()->OnNodeAttach(nodeId_, otherNodeId); }
+        { GetGraphPtr()->OnNodeAttach(nodeId_, otherNodeId); }
 
     void DetachFromMe(NodeId otherNodeId)
-        { GraphPtr()->OnNodeDetach(nodeId_, otherNodeId); }
+        { GetGraphPtr()->OnNodeDetach(nodeId_, otherNodeId); }
 
     void DynamicAttachToMe(NodeId otherNodeId, TurnId turnId)
-        { GraphPtr()->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
+        { GetGraphPtr()->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
 
     void DynamicDetachFromMe(NodeId otherNodeId, TurnId turnId)
-        { GraphPtr()->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
+        { GetGraphPtr()->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
 
 private:
     NodeId nodeId_;
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index d383d341..c84e06d0 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -10,6 +10,7 @@
 #pragma once
 
 #include "react/detail/Defs.h"
+#include "react/API.h"
 
 #include <memory>
 #include <utility>
@@ -35,8 +36,8 @@ class EventStreamNode;
 class ObserverNode : public NodeBase
 {
 public:
-    ObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
-        ObserverNode::NodeBase( graphPtr )
+    ObserverNode(const Group& group) :
+        ObserverNode::NodeBase( group )
         { }
 };
 
@@ -48,18 +49,18 @@ class SignalObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SignalObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
-        SignalObserverNode::ObserverNode( graphPtr ),
+    SignalObserverNode(const Group& group, FIn&& func, const Signal<TDeps>& ... deps) :
+        SignalObserverNode::ObserverNode( group ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
         this->RegisterMe(NodeCategory::output);
-        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
     }
 
     ~SignalObserverNode()
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(deps->GetNodeId())); }, depHolder_);
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
@@ -71,14 +72,14 @@ class SignalObserverNode : public ObserverNode
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        apply([this] (const auto& ... deps) { this->func_(deps->Value() ...); }, depHolder_);
+        apply([this] (const auto& ... deps) { this->func_(GetInternals(deps).Value() ...); }, depHolder_);
         return UpdateResult::unchanged;
     }
 
 private:
     F func_;
 
-    std::tuple<std::shared_ptr<SignalNode<TDeps>> ...> depHolder_;
+    std::tuple<Signal<TDeps> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -89,18 +90,18 @@ class EventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    EventObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject) :
-        EventObserverNode::ObserverNode( graphPtr ),
+    EventObserverNode(const Group& group, FIn&& func, const Event<E>& subject) :
+        EventObserverNode::ObserverNode( group ),
         func_( std::forward<FIn>(func) ),
         subject_( subject )
     {
         this->RegisterMe(NodeCategory::output);
-        this->AttachToMe(subject->GetNodeId());
+        this->AttachToMe(GetInternals(subject).GetNodeId());
     }
 
     ~EventObserverNode()
     {
-        this->DetachFromMe(subject_->GetNodeId());
+        this->DetachFromMe(GetInternals(subject_).GetNodeId());
         this->UnregisterMe();
     }
 
@@ -112,15 +113,15 @@ class EventObserverNode : public ObserverNode
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        func_(EventRange<E>( subject_->Events() ));
-        subject_->DecrementPendingSuccessorCount();
+        func_(EventRange<E>( GetInternals(subject_).Events() ));
+        GetInternals(subject_).DecrementPendingSuccessorCount();
         return UpdateResult::unchanged;
     }
 
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<E>> subject_;
+    Event<E> subject_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -131,21 +132,21 @@ class SyncedEventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SyncedEventObserverNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<EventStreamNode<E>>& subject, const std::shared_ptr<SignalNode<TSyncs>>& ... syncs) :
-        SyncedEventObserverNode::ObserverNode( graphPtr ),
+    SyncedEventObserverNode(const Group& group, FIn&& func, const Event<E>& subject, const Signal<TSyncs>& ... syncs) :
+        SyncedEventObserverNode::ObserverNode( group ),
         func_( std::forward<FIn>(func) ),
         subject_( subject ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe(NodeCategory::output);
         this->AttachToMe(subject->GetNodeId());
-        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(syncs).GetNodeId()));
     }
 
     ~SyncedEventObserverNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(subject_->GetNodeId());
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(GetInternals(subject_).GetNodeId());
         this->UnregisterMe();
     }
 
@@ -158,12 +159,12 @@ class SyncedEventObserverNode : public ObserverNode
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
-        if (subject_->Events().empty())
+        if (GetInternals(this->subject_).Events().empty())
             return UpdateResult::unchanged;
 
-        apply([this] (const auto& ... syncs) { func_(EventRange<E>( this->subject_->Events() ), syncs->Value() ...); }, syncHolder_);
+        apply([this] (const auto& ... syncs) { func_(EventRange<E>( GetInternals(this->subject_).Events() ), GetInternals(syncs).Value() ...); }, syncHolder_);
 
-        subject_->DecrementPendingSuccessorCount();
+        GetInternals(subject_).DecrementPendingSuccessorCount();
 
         return UpdateResult::unchanged;
     }
@@ -171,9 +172,9 @@ class SyncedEventObserverNode : public ObserverNode
 private:
     F func_;
 
-    std::shared_ptr<EventStreamNode<E>> subject_;
+    Event<E> subject_;
 
-    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
+    std::tuple<Signal<TSyncs> ...> syncHolder_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 4dbd8574..b25b46d9 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -39,14 +39,14 @@ class SignalNode : public NodeBase
     SignalNode(const SignalNode&) = delete;
     SignalNode& operator=(const SignalNode&) = delete;
 
-    explicit SignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
-        SignalNode::NodeBase( graphPtr ),
+    explicit SignalNode(const Group& group) :
+        SignalNode::NodeBase( group ),
         value_( )
         { }
 
     template <typename T>
-    SignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& value) :
-        SignalNode::NodeBase( graphPtr ),
+    SignalNode(const Group& group, T&& value) :
+        SignalNode::NodeBase( group ),
         value_( std::forward<T>(value) )
         { }
 
@@ -67,19 +67,25 @@ template <typename S>
 class VarSignalNode : public SignalNode<S>
 {
 public:
-    explicit VarSignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr) :
-        VarSignalNode::SignalNode( graphPtr ),
+    explicit VarSignalNode(const Group& group) :
+        VarSignalNode::SignalNode( group ),
         newValue_( )
-        { this->RegisterMe(NodeCategory::input); }
+    {
+        this->RegisterMe(NodeCategory::input);
+    }
 
     template <typename T>
-    VarSignalNode(const std::shared_ptr<ReactiveGraph>& graphPtr, T&& value) :
-        VarSignalNode::SignalNode( graphPtr, std::forward<T>(value) ),
+    VarSignalNode(const Group& group, T&& value) :
+        VarSignalNode::SignalNode( group, std::forward<T>(value) ),
         newValue_( value )
-        { this->RegisterMe(); }
+    {
+        this->RegisterMe();
+    }
 
     ~VarSignalNode()
-        { this->UnregisterMe(); }
+    {
+        this->UnregisterMe();
+    }
 
     virtual const char* GetNodeType() const override
         { return "VarSignal"; }
@@ -161,8 +167,8 @@ class SignalFuncNode : public SignalNode<S>
 {
 public:
     template <typename FIn>
-    SignalFuncNode(const std::shared_ptr<ReactiveGraph>& graphPtr, FIn&& func, const std::shared_ptr<SignalNode<TDeps>>& ... deps) :
-        SignalFuncNode::SignalNode( graphPtr, func(deps->Value() ...) ),
+    SignalFuncNode(const Group& group, FIn&& func, const Signal<TDeps>& ... deps) :
+        SignalFuncNode::SignalNode( group, func(deps->Value() ...) ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
@@ -172,7 +178,7 @@ class SignalFuncNode : public SignalNode<S>
 
     ~SignalFuncNode()
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(deps->GetNodeId())); }, depHolder_);
+        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodePtr()->GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
@@ -186,7 +192,7 @@ class SignalFuncNode : public SignalNode<S>
     {   
         bool changed = false;
 
-        S newValue = apply([this] (const auto& ... deps) { return this->func_(deps->Value() ...); }, depHolder_);
+        S newValue = apply([this] (const auto& ... deps) { return this->func_(GetInternals(deps).Value() ...); }, depHolder_);
 
         if (! (this->Value() == newValue))
         {
@@ -203,7 +209,7 @@ class SignalFuncNode : public SignalNode<S>
 private:
     F func_;
 
-    std::tuple<std::shared_ptr<SignalNode<TDeps>> ...> depHolder_;
+    std::tuple<Signal<TDeps> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -213,8 +219,8 @@ template <typename S>
 class SignalSlotNode : public SignalNode<S>
 {
 public:
-    SignalSlotNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<SignalNode<S>>& dep) :
-        SignalSlotNode::SignalNode( graphPtr, dep->Value() ),
+    SignalSlotNode(const Group& group, const Signal<S>& dep) :
+        SignalSlotNode::SignalNode( group, dep->Value() ),
         slotInput_( *this, dep )
     {
         slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
@@ -226,11 +232,13 @@ class SignalSlotNode : public SignalNode<S>
 
     ~SignalSlotNode()
     {
-        this->DetachFromMe(slotInput_.dep->GetNodeId());
+        const auto& depNodePtr = GetInternals(slotInput_.dep).GetNodePtr();
+
+        this->DetachFromMe(depNodePtr->GetNodeId());
         this->DetachFromMe(slotInput_.nodeId);
 
         this->UnregisterMe();
-        GraphPtr()->UnregisterNode(slotInput_.nodeId);
+        GetGraphPtr()->UnregisterNode(slotInput_.nodeId);
     }
 
     virtual const char* GetNodeType() const override
@@ -241,9 +249,11 @@ class SignalSlotNode : public SignalNode<S>
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        if (! (this->Value() == slotInput_.dep->Value()))
+        const auto& depNodePtr = GetInternals(slotInput_.dep).GetNodePtr();
+
+        if (! (this->Value() == depNodePtr->Value()))
         {
-            this->Value() = slotInput_.dep->Value();
+            this->Value() = depNodePtr->Value();
             return UpdateResult::changed;
         }
         else
@@ -252,7 +262,7 @@ class SignalSlotNode : public SignalNode<S>
         }
     }
 
-    void SetInput(const std::shared_ptr<SignalNode<S>>& newInput)
+    void SetInput(const Signal<S>& newInput)
         { slotInput_.newDep = newInput; }
 
     NodeId GetInputNodeId() const
@@ -261,9 +271,10 @@ class SignalSlotNode : public SignalNode<S>
 private:        
     struct VirtualInputNode : public IReactiveNode
     {
-        VirtualInputNode(SignalSlotNode& parentIn, const std::shared_ptr<SignalNode<S>>& depIn) :
+        VirtualInputNode(SignalSlotNode& parentIn, const Signal<S>& depIn) :
             parent( parentIn ),
-            dep( depIn )
+            dep( depIn ),
+            newDep( depIn ),
             { }
 
         virtual const char* GetNodeType() const override
@@ -276,15 +287,17 @@ class SignalSlotNode : public SignalNode<S>
         {
             if (dep != newDep)
             {
-                parent.DynamicDetachFromMe(dep->GetNodeId(), 0);
-                parent.DynamicAttachToMe(newDep->GetNodeId(), 0);
+                const auto& depNodePtr = GetInternals(dep).GetNodePtr();
+                const auto& newDepNodePtr = GetInternals(newDep).GetNodePtr();
+
+                parent.DynamicDetachFromMe(depNodePtr->GetNodeId(), 0);
+                parent.DynamicAttachToMe(newDepNodePtr->GetNodeId(), 0);
 
                 dep = std::move(newDep);
                 return UpdateResult::changed;
             }
             else
             {
-                newDep.reset();
                 return UpdateResult::unchanged;
             }
         }
@@ -293,8 +306,8 @@ class SignalSlotNode : public SignalNode<S>
 
         NodeId nodeId;
 
-        std::shared_ptr<SignalNode<S>> dep;
-        std::shared_ptr<SignalNode<S>> newDep;
+        Signal<S> dep;
+        Signal<S> newDep;
     };
 
     VirtualInputNode slotInput_;
@@ -307,9 +320,9 @@ template <typename S>
 class SignalLinkNode : public SignalNode<S>
 {
 public:
-    SignalLinkNode(const std::shared_ptr<ReactiveGraph>& graphPtr, const std::shared_ptr<ReactiveGraph>& srcGraphPtr, const std::shared_ptr<SignalNode<S>>& dep) :
-        SignalLinkNode::SignalNode( graphPtr, dep->Value() ),
-        linkOutput_( srcGraphPtr, dep )
+    SignalLinkNode(const Group& group, const Group& srcGroup, const Signal<S>& dep) :
+        SignalLinkNode::SignalNode( group, dep->Value() ),
+        linkOutput_( srcGroup, dep )
     {
         this->RegisterMe(NodeCategory::input);
     }
@@ -329,22 +342,18 @@ class SignalLinkNode : public SignalNode<S>
         { return 1; }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
-    {
-        return UpdateResult::changed;
-    }
+        { return UpdateResult::changed; }
 
     template <typename T>
     void SetValue(T&& newValue)
-    {
-        this->Value() = std::forward<T>(newValue);
-    }
+        { this->Value() = std::forward<T>(newValue); }
 
 private:
     struct VirtualOutputNode : public ILinkOutputNode
     {
-        VirtualOutputNode(const std::shared_ptr<ReactiveGraph>& srcGraphPtrIn, const std::shared_ptr<SignalNode<S>>& depIn) :
+        VirtualOutputNode(const Group& srcGroupIn, const Signal<S>& depIn) :
             parent( ),
-            srcGraphPtr( srcGraphPtrIn ),
+            srcGroup( srcGroupIn ),
             dep( depIn )
         {
             nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
@@ -364,9 +373,7 @@ class SignalLinkNode : public SignalNode<S>
             { return 1; }
 
         virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
-        {   
-            return UpdateResult::changed;
-        }
+            { return UpdateResult::changed; }
 
         virtual void CollectOutput(LinkOutputMap& output) override
         {
@@ -392,9 +399,9 @@ class SignalLinkNode : public SignalNode<S>
 
         NodeId nodeId;
 
-        std::shared_ptr<SignalNode<S>> dep;
+        Signal<S> dep;
 
-        std::shared_ptr<ReactiveGraph> srcGraphPtr;
+        Group srcGroup;
     };
 
     VirtualOutputNode linkOutput_;

From b70012f98e26479af24eb2ce49b2593c80b5e4eb Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 4 Jan 2017 22:17:46 +0100
Subject: [PATCH 47/75] progress

---
 include/react/Event.h                       |  14 +-
 include/react/Signal.h                      |  27 +---
 include/react/detail/graph/AlgorithmNodes.h | 134 ++++++++++----------
 include/react/detail/graph/EventNodes.h     |  94 ++++++++++----
 include/react/detail/graph/GraphBase.h      |   4 +-
 include/react/detail/graph/ObserverNodes.h  |   2 +-
 include/react/detail/graph/SignalNodes.h    |  52 ++++----
 7 files changed, 171 insertions(+), 156 deletions(-)

diff --git a/include/react/Event.h b/include/react/Event.h
index e4d2a987..01c284c6 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -49,10 +49,10 @@ class EventInternals
         { return nodePtr_->GetNodeId(); }
 
     StorageType& Events()
-        { return nodePtr->Events(); }
+        { return nodePtr_->Events(); }
 
     const StorageType& Events() const
-        { return nodePtr->Events(); }
+        { return nodePtr_->Events(); }
 
     void SetPendingSuccessorCount(size_t count)
         { nodePtr_->SetPendingSuccessorCount(count); }
@@ -383,7 +383,7 @@ auto Transform(const Group& group, F&& op, const Event<T>& dep) -> Event<E>
 
 template <typename E, typename F, typename T>
 auto Transform(F&& op, const Event<T>& dep) -> Event<E>
-    { return Transform(dep1.GetGroup(), std::forward<F>(op), dep); }
+    { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep); }
 
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
@@ -399,7 +399,7 @@ auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>
 
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
-    { return Transform(dep.GetGroup(), std::forward<F>(op), dep, signals ...); }
+    { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep, signals ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
@@ -451,12 +451,6 @@ auto Tokenize(T&& source) -> decltype(auto)
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-template <typename L, typename R>
-bool Equals(const Event<L>& lhs, const Event<R>& rhs)
-{
-    return lhs.Equals(rhs);
-}
-
 template <typename E>
 static Event<E> SameGroupOrLink(const Group& targetGroup, const Event<E>& dep)
 {
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 58e5da37..10ed71f8 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -205,7 +205,7 @@ class VarSignal : public Signal<S>
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->GetNodePtr().get());
         
         NodeId nodeId = castedPtr->GetNodeId();
-        auto& graphPtr = BaseCast(this->GetGroup()).GetGraphPtr();
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
         graphPtr->AddInput(nodeId, [castedPtr, &func] { castedPtr->ModifyValue(func); });
     }
@@ -224,17 +224,12 @@ class SignalSlot : public Signal<S>
     SignalSlot(SignalSlot&&) = default;
     SignalSlot& operator=(SignalSlot&&) = default;
 
-    // Construct with group + default
-    explicit SignalSlot(const Group& group) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(group) )
-        { }
-
-    // Construct with group + value
+    // Construct with explicit group
     SignalSlot(const Group& group, const Signal<S>& input) :
         SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
         { }
 
-    // Construct with value
+    // Construct with implicit group
     explicit SignalSlot(const Signal<S>& input) :
         SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(input.GetGroup(), input) )
         { }
@@ -246,12 +241,6 @@ class SignalSlot : public Signal<S>
         { SetInput(newInput); }
 
 protected:
-    static auto CreateSlotNode(const Group& group) -> decltype(auto)
-    {
-        using REACT_IMPL::SignalSlotNode;
-        return std::make_shared<SignalSlotNode<S>>(group);
-    }
-
     static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::SignalSlotNode;
@@ -301,7 +290,7 @@ class SignalLink : public Signal<S>
     {
         using REACT_IMPL::SignalLinkNode;
 
-        auto node = std::make_shared<SignalLinkNode<S>>(group, PrivateNodeInterface::GraphPtr(input), PrivateNodeInterface::NodePtr(input));
+        auto node = std::make_shared<SignalLinkNode<S>>(group, input);
         node->SetWeakSelfPtr(std::weak_ptr<SignalLinkNode<S>>{ node });
         return node;
     }
@@ -311,19 +300,13 @@ class SignalLink : public Signal<S>
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-template <typename L, typename R>
-bool Equals(const Signal<L>& lhs, const Signal<R>& rhs)
-{
-    return lhs.Equals(rhs);
-}
-
 template <typename S>
 static Signal<S> SameGroupOrLink(const Group& targetGroup, const Signal<S>& dep)
 {
     if (dep.GetGroup() == targetGroup)
         return dep;
     else
-        return SignalLink<S>( group, dep );
+        return SignalLink<S>( targetGroup, dep );
 }
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/graph/AlgorithmNodes.h
index 0287a816..fdb925e1 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/graph/AlgorithmNodes.h
@@ -86,26 +86,26 @@ class IterateNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    IterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& events) :
+    IterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt) :
         IterateNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
-        events_( events )
+        evnt_( evnt )
     {
         this->RegisterMe();
-        this->AttachToMe(events->GetNodeId());
+        this->AttachToMe(GetInternals(evnt).GetNodeId());
     }
 
     ~IterateNode()
     {
-        this->DetachFromMe(events_->GetNodeId());
+        this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        S newValue = func_(EventRange<E>( events_->Events() ), this->Value());
+        S newValue = func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value());
 
-        events_->DecrementPendingSuccessorCount();
+        GetInternals(evnt_).DecrementPendingSuccessorCount();
 
         if (! (newValue == this->Value()))
         {
@@ -125,9 +125,8 @@ class IterateNode : public SignalNode<S>
         { return 1; }
 
 private:
-    Event<E> events_;
-    
-    F func_;
+    F           func_;
+    Event<E>    evnt_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -138,26 +137,26 @@ class IterateByRefNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    IterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& events) :
+    IterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt) :
         IterateByRefNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
-        events_( events )
+        evnt_( evnt )
     {
         this->RegisterMe();
-        this->AttachToMe(events->GetNodeId());
+        this->AttachToMe(GetInternals(evnt_).GetNodeId());
     }
 
     ~IterateByRefNode()
     {
-        this->DetachFromMe(events_->GetNodeId());
+        this->DetachFromMe(GetInternals(evnt).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        func_(EventRange<E>( events_->Events() ), this->Value());
+        func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value());
 
-        events_->DecrementPendingSuccessorCount();
+        GetInternals(evnt_).DecrementPendingSuccessorCount();
 
         // Always assume change
         return UpdateResult::changed;
@@ -170,9 +169,8 @@ class IterateByRefNode : public SignalNode<S>
         { return 1; }
 
 protected:
-    F   func_;
-
-    Event<E> events_;
+    F           func_;
+    Event<E>    evnt_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -183,38 +181,38 @@ class SyncedIterateNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& events, const Signal<TSyncs>& ... syncs) :
+    SyncedIterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt, const Signal<TSyncs>& ... syncs) :
         SyncedIterateNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
-        events_( events ),
+        evnt_( evnt ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
-        this->AttachToMe(events->GetNodeId());
-        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
+        this->AttachToMe(GetInternals(evnt).GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(syncs).GetNodeId()));
     }
 
     ~SyncedIterateNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(events_->GetNodeId());
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
-        if (events_->Events().empty())
+        if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
         S newValue = apply(
             [this] (const auto& ... syncs)
             {
-                return func_(EventRange<E>( events_->Events() ), this->Value(), syncs->Value() ...);
+                return func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(syncs).Value() ...);
             },
             syncHolder_);
 
-        events_->DecrementPendingSuccessorCount();
+        GetInternals(evnt_).DecrementPendingSuccessorCount();
 
         if (! (newValue == this->Value()))
         {
@@ -234,11 +232,10 @@ class SyncedIterateNode : public SignalNode<S>
         { return 1 + sizeof...(TSyncs); }
 
 private:
-    F func_;
-
-    Event<E> events_;
+    F           func_;
+    Event<E>    evnt_;
 
-    std::tuple<std::shared_ptr<SignalNode<TSyncs>>...> syncHolder_;
+    std::tuple<Signal<TSyncs> ...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -249,38 +246,38 @@ class SyncedIterateByRefNode : public SignalNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& events, const Signal<TSyncs>& ... syncs) :
+    SyncedIterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt, const Signal<TSyncs>& ... syncs) :
         SyncedIterateByRefNode::SignalNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
-        events_( events ),
+        evnt_( evnt ),
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
-        this->AttachToMe(events->GetNodeId());
-        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
+        this->AttachToMe(GetInternals(evnt).GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(syncs).GetNodeId()));
     }
 
     ~SyncedIterateByRefNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(events_->GetNodeId());
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
-        if (events_->Events().empty())
+        if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
         apply(
             [this] (const auto& ... args)
             {
-                func_(EventRange<E>( events_->Events() ), this->Value(), args->Value() ...);
+                func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(args).Value() ...);
             },
             syncHolder_);
 
-        events_->DecrementPendingSuccessorCount();
+        GetInternals(evnt_).DecrementPendingSuccessorCount();
 
         return UpdateResult::changed;
     }
@@ -292,9 +289,8 @@ class SyncedIterateByRefNode : public SignalNode<S>
         { return 1 + sizeof...(TSyncs); }
 
 private:
-    F func_;
-
-    Event<E> events_;
+    F           func_;
+    Event<E>    events_;
 
     std::tuple<Signal<TSyncs> ...> syncHolder_;
 };
@@ -307,17 +303,17 @@ class HoldNode : public SignalNode<S>
 {
 public:
     template <typename T>
-    HoldNode(const Group& group, T&& init, const Event<S>& events) :
+    HoldNode(const Group& group, T&& init, const Event<S>& evnt) :
         HoldNode::SignalNode( group, std::forward<T>(init) ),
-        events_( events )
+        evnt_( evnt )
     {
         this->RegisterMe();
-        this->AttachToMe(events->GetNodeId());
+        this->AttachToMe(GetInternals(evnt).GetNodeId());
     }
 
     ~HoldNode()
     {
-        this->DetachFromMe(events_->GetNodeId());
+        this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
@@ -328,9 +324,9 @@ class HoldNode : public SignalNode<S>
     {
         bool changed = false;
 
-        if (! events_->Events().empty())
+        if (! GetInternals(evnt_).Events().empty())
         {
-            const S& newValue = events_->Events().back();
+            const S& newValue = GetInternals(evnt_).Events().back();
 
             if (! (newValue == this->Value()))
             {
@@ -338,7 +334,7 @@ class HoldNode : public SignalNode<S>
                 this->Value() = newValue;
             }
 
-            events_->DecrementPendingSuccessorCount();
+            GetInternals(evnt_).DecrementPendingSuccessorCount();
         }
 
         if (changed)
@@ -351,7 +347,7 @@ class HoldNode : public SignalNode<S>
         { return 1; }
 
 private:
-    const Event<S>    events_;
+    Event<S>  evnt_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -362,19 +358,19 @@ class SnapshotNode : public SignalNode<S>
 {
 public:
     SnapshotNode(const Group& group, const Signal<S>& target, const Event<E>& trigger) :
-        SnapshotNode::SignalNode( group, target->Value() ),
+        SnapshotNode::SignalNode( group, GetInternals(target).Value() ),
         target_( target ),
         trigger_( trigger )
     {
         this->RegisterMe();
-        this->AttachToMe(target->GetNodeId());
-        this->AttachToMe(trigger->GetNodeId());
+        this->AttachToMe(GetInternals(target).GetNodeId());
+        this->AttachToMe(GetInternals(trigger).GetNodeId());
     }
 
     ~SnapshotNode()
     {
-        this->DetachFromMe(trigger_->GetNodeId());
-        this->DetachFromMe(target_->GetNodeId());
+        this->DetachFromMe(GetInternals(trigger_).GetNodeId());
+        this->DetachFromMe(GetInternals(target_).GetNodeId());
         this->UnregisterMe();
     }
 
@@ -382,9 +378,9 @@ class SnapshotNode : public SignalNode<S>
     {
         bool changed = false;
         
-        if (! trigger_->Events().empty())
+        if (! GetInternals(trigger_).Events().empty())
         {
-            const S& newValue = target_->Value();
+            const S& newValue = GetInternals(target_).Value();
 
             if (! (newValue == this->Value()))
             {
@@ -392,7 +388,7 @@ class SnapshotNode : public SignalNode<S>
                 this->Value() = newValue;
             }
 
-            trigger_->DecrementPendingSuccessorCount();
+            GetInternals(trigger_).DecrementPendingSuccessorCount();
         }
 
         if (changed)
@@ -424,18 +420,18 @@ class MonitorNode : public EventStreamNode<S>
         target_( target )
     {
         this->RegisterMe();
-        this->AttachToMe(target->GetNodeId());
+        this->AttachToMe(GetInternals(target).GetNodeId());
     }
 
     ~MonitorNode()
     {
-        this->DetachFromMe(target_->GetNodeId());
+        this->DetachFromMe(GetInternals(target_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        this->Events().push_back(target_->Value());
+        this->Events().push_back(GetInternals(target_).Value());
 
         this->SetPendingSuccessorCount(successorCount);
 
@@ -465,23 +461,23 @@ class PulseNode : public EventStreamNode<S>
         trigger_( trigger )
     {
         this->RegisterMe();
-        this->AttachToMe(target->GetNodeId());
-        this->AttachToMe(trigger->GetNodeId());
+        this->AttachToMe(GetInternals(target).GetNodeId());
+        this->AttachToMe(GetInternals(trigger).GetNodeId());
     }
 
     ~PulseNode()
     {
-        this->DetachFromMe(trigger_->GetNodeId());
-        this->DetachFromMe(target_->GetNodeId());
+        this->DetachFromMe(GetInternals(trigger_).GetNodeId());
+        this->DetachFromMe(GetInternals(target_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        for (size_t i=0; i<trigger_->Events().size(); i++)
-            this->Events().push_back(target_->Value());
+        for (size_t i = 0; i < GetInternals(trigger_).Events().size(); i++)
+            this->Events().push_back(GetInternals(target_).Value());
 
-        trigger_->DecrementPendingSuccessorCount();
+        GetInternals(trigger_).DecrementPendingSuccessorCount();
 
         if (! this->Events().empty())
         {
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index c8d91af0..f720fc18 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -184,7 +184,7 @@ class EventMergeNode : public EventStreamNode<TOut>
         depHolder_( deps ... )
     {
         this->RegisterMe();
-        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
     }
 
     ~EventMergeNode()
@@ -195,7 +195,7 @@ class EventMergeNode : public EventStreamNode<TOut>
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
+        apply([this] (auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
         if (! this->Events().empty())
         {
@@ -216,12 +216,13 @@ class EventMergeNode : public EventStreamNode<TOut>
 
 private:
     template <typename U>
-    void MergeFromDep(const Event<U>& dep)
+    void MergeFromDep(Event<U>& dep)
     {
-        auto& depNodePtr = BaseCast(dep).GetNodePtr();
+        auto& depInternals = GetInternals(dep);
 
-        this->Events().insert(this->Events().end(), depNodePtr->Events().begin(), depNodePtr->Events().end());
-        depNodePtr->DecrementPendingSuccessorCount();
+        this->Events().insert(this->Events().end(), depInternals.Events().begin(), depInternals.Events().end());
+        
+        depInternals.DecrementPendingSuccessorCount();
     }
 
     std::tuple<Event<TIns> ...> depHolder_;
@@ -234,20 +235,20 @@ template <typename E>
 class EventSlotNode : public EventStreamNode<E>
 {
 public:
-    EventSlotNode(const Group& group, const Event<E>& dep) :
+    EventSlotNode(const Group& group) :
         EventSlotNode::EventStreamNode( group ),
-        slotInput_( *this, dep )
+        slotInput_( *this )
     {
         slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
         this->RegisterMe();
 
         this->AttachToMe(slotInput_.nodeId);
-        this->AttachToMe(dep->GetNodeId());
+        //this->AttachToMe(GetInternals(dep).GetNodeId());
     }
 
     ~EventSlotNode()
     {
-        this->DetachFromMe(slotInput_.dep->GetNodeId());
+        this->DetachFromMe(GetInternals(slotInput_.dep).GetNodeId());
         this->DetachFromMe(slotInput_.nodeId);
 
         this->UnregisterMe();
@@ -277,8 +278,45 @@ class EventSlotNode : public EventStreamNode<E>
         }
     }
 
-    void SetInput(const std::shared_ptr<EventStreamNode<E>>& newInput)
-        { slotInput_.newDep = newInput; }
+    void AddInput(const Event<E>>& input)
+    {
+        auto& newDeps = slotInput_.newDeps;
+
+        for (auto& e : newDeps)
+        {
+            if (e.second != input)
+                continue;
+
+            // Earlier remove is overridden by later add.
+            if (e.first == false)
+                e.first = true;
+            
+            // Either element was already added, or remove has been overridden. Nothing more to do.
+            return;
+        }
+
+        newDeps.emplace_back(true, input);
+    }
+
+    void RemoveInput(const Event<E>& input)
+    {
+        auto& newDeps = slotInput_.newDeps;
+
+        for (auto& e : newDeps)
+        {
+            if (e.second != input)
+                continue;
+
+            // Earlier add is overridden by later remove.
+            if (e.first == true)
+                e.first = false;
+            
+            // Either element was already removed, or add has been overridden. Nothing more to do.
+            return;
+        }
+
+        newDeps.emplace_back(false, input);
+    }
 
     NodeId GetInputNodeId() const
         { return slotInput_.nodeId; }
@@ -318,8 +356,8 @@ class EventSlotNode : public EventStreamNode<E>
 
         NodeId nodeId;
 
-        Event<E> dep;
-        Event<E> newDep;
+        std::vector<Event<E>> deps;
+        std::vector<std::pair<bool /* isAdded */, Event<E>>> newDeps;
     };
 
     VirtualInputNode slotInput_;
@@ -339,20 +377,20 @@ class EventProcessingNode : public EventStreamNode<TOut>
         dep_( dep )
     {
         this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
+        this->AttachToMe(GetInternals(dep).GetNodeId());
     }
 
     ~EventProcessingNode()
     {
-        this->DetachFromMe(dep_->GetNodeId());
+        this->DetachFromMe(GetInternals(dep_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        func_(EventRange<TIn>( dep_->Events() ), std::back_inserter(this->Events()));
+        func_(EventRange<TIn>( GetInternals(dep_).Events() ), std::back_inserter(this->Events()));
 
-        dep_->DecrementPendingSuccessorCount();
+        GetInternals(dep_).DecrementPendingSuccessorCount();
 
         if (! this->Events().empty())
         {
@@ -455,12 +493,12 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         slots_( deps ... )
     {
         this->RegisterMe();
-        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
     }
 
     ~EventJoinNode()
     {
-        apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(slots.source->GetNodeId())); }, slots_);
+        apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
         this->UnregisterMe();
     }
 
@@ -527,8 +565,8 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
     template <typename U>
     static void FetchBuffer(TurnId turnId, Slot<U>& slot)
     {
-        slot.buffer.insert(slot.buffer.end(), slot.source->Events().begin(), slot.source->Events().end());
-        slot.source->DecrementPendingSuccessorCount();
+        slot.buffer.insert(slot.buffer.end(), GetInternals(slot.source).Events().begin(), GetInternals(slot.source).Events().end());
+        GetInternals(slot.source).DecrementPendingSuccessorCount();
     }
 
     template <typename T>
@@ -586,13 +624,15 @@ class EventLinkNode : public EventStreamNode<E>
             dep( depIn ),
             srcGroup( depIn.GetGroup() )
         {
+            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
             nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-            srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
+            srcGraphPtr->OnNodeAttach(nodeId, GetInternals(dep).GetNodeId());
         }
 
         ~VirtualOutputNode()
         {
-            srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
+            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
+            srcGraphPtr->OnNodeDetach(nodeId, GetInternals(dep).GetNodeId());
             srcGraphPtr->UnregisterNode(nodeId);
         }
 
@@ -609,12 +649,12 @@ class EventLinkNode : public EventStreamNode<E>
         {
             if (auto p = parent.lock())
             {
-                auto* rawPtr = p->GraphPtr().get();
+                auto* rawPtr = p->GetGraphPtr().get();
                 output[rawPtr].push_back(
-                    [storedParent = std::move(p), storedEvents = dep->Events()] () mutable
+                    [storedParent = std::move(p), storedEvents = GetInternals(dep).Events()] () mutable
                     {
                         NodeId nodeId = storedParent->GetNodeId();
-                        auto& graphPtr = storedParent->GraphPtr();
+                        auto& graphPtr = storedParent->GetGraphPtr();
 
                         graphPtr->AddInput(nodeId,
                             [&storedParent, &storedEvents]
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index a3769ce3..43f58f89 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -66,10 +66,10 @@ class NodeBase : public IReactiveNode
 
 protected:
     auto GetGraphPtr() const -> const std::shared_ptr<ReactiveGraph>&
-        { GetInternals(group_).GetGraphPtr(); }
+        { return GetInternals(group_).GetGraphPtr(); }
 
     auto GetGraphPtr() -> std::shared_ptr<ReactiveGraph>&
-        { GetInternals(group_).GetGraphPtr(); }
+        { return GetInternals(group_).GetGraphPtr(); }
 
     void RegisterMe(NodeCategory category = NodeCategory::normal)
         { nodeId_ = GetGraphPtr()->RegisterNode(this, category); }
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/graph/ObserverNodes.h
index c84e06d0..695c0792 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/graph/ObserverNodes.h
@@ -139,7 +139,7 @@ class SyncedEventObserverNode : public ObserverNode
         syncHolder_( syncs ... )
     {
         this->RegisterMe(NodeCategory::output);
-        this->AttachToMe(subject->GetNodeId());
+        this->AttachToMe(GetInternals(subject).GetNodeId());
         REACT_EXPAND_PACK(this->AttachToMe(GetInternals(syncs).GetNodeId()));
     }
 
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index b25b46d9..d137c506 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -168,12 +168,12 @@ class SignalFuncNode : public SignalNode<S>
 public:
     template <typename FIn>
     SignalFuncNode(const Group& group, FIn&& func, const Signal<TDeps>& ... deps) :
-        SignalFuncNode::SignalNode( group, func(deps->Value() ...) ),
+        SignalFuncNode::SignalNode( group, func(GetInternals(deps).Value() ...) ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
         this->RegisterMe();
-        REACT_EXPAND_PACK(this->AttachToMe(deps->GetNodeId()));
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
     }
 
     ~SignalFuncNode()
@@ -220,14 +220,14 @@ class SignalSlotNode : public SignalNode<S>
 {
 public:
     SignalSlotNode(const Group& group, const Signal<S>& dep) :
-        SignalSlotNode::SignalNode( group, dep->Value() ),
+        SignalSlotNode::SignalNode( group, GetInternals(dep).Value() ),
         slotInput_( *this, dep )
     {
-        slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
+        slotInput_.nodeId = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
         this->RegisterMe();
 
         this->AttachToMe(slotInput_.nodeId);
-        this->AttachToMe(dep->GetNodeId());
+        this->AttachToMe(GetInternals(dep).GetNodeId());
     }
 
     ~SignalSlotNode()
@@ -263,6 +263,9 @@ class SignalSlotNode : public SignalNode<S>
     }
 
     void SetInput(const Signal<S>& newInput)
+    {
+        slotInput_.isChanged = true;
+    }
         { slotInput_.newDep = newInput; }
 
     NodeId GetInputNodeId() const
@@ -273,8 +276,7 @@ class SignalSlotNode : public SignalNode<S>
     {
         VirtualInputNode(SignalSlotNode& parentIn, const Signal<S>& depIn) :
             parent( parentIn ),
-            dep( depIn ),
-            newDep( depIn ),
+            dep( depIn )
             { }
 
         virtual const char* GetNodeType() const override
@@ -306,8 +308,8 @@ class SignalSlotNode : public SignalNode<S>
 
         NodeId nodeId;
 
-        Signal<S> dep;
-        Signal<S> newDep;
+        Signal<S>   dep;
+        bool        isChanged = false;
     };
 
     VirtualInputNode slotInput_;
@@ -320,9 +322,9 @@ template <typename S>
 class SignalLinkNode : public SignalNode<S>
 {
 public:
-    SignalLinkNode(const Group& group, const Group& srcGroup, const Signal<S>& dep) :
-        SignalLinkNode::SignalNode( group, dep->Value() ),
-        linkOutput_( srcGroup, dep )
+    SignalLinkNode(const Group& group, const Signal<S>& dep) :
+        SignalLinkNode::SignalNode( group, GetInternals(dep).Value() ),
+        linkOutput_( dep )
     {
         this->RegisterMe(NodeCategory::input);
     }
@@ -351,18 +353,20 @@ class SignalLinkNode : public SignalNode<S>
 private:
     struct VirtualOutputNode : public ILinkOutputNode
     {
-        VirtualOutputNode(const Group& srcGroupIn, const Signal<S>& depIn) :
+        VirtualOutputNode(const Signal<S>& depIn) :
             parent( ),
-            srcGroup( srcGroupIn ),
-            dep( depIn )
+            dep( depIn ),
+            srcGroup( depIn.GetGroup() )
         {
+            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
             nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-            srcGraphPtr->OnNodeAttach(nodeId, dep->GetNodeId());
+            srcGraphPtr->OnNodeAttach(nodeId, GetInternals(dep).GetNodeId());
         }
 
         ~VirtualOutputNode()
         {
-            srcGraphPtr->OnNodeDetach(nodeId, dep->GetNodeId());
+            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
+            srcGraphPtr->OnNodeDetach(nodeId, GetInternals(dep).GetNodeId());
             srcGraphPtr->UnregisterNode(nodeId);
         }
 
@@ -379,12 +383,12 @@ class SignalLinkNode : public SignalNode<S>
         {
             if (auto p = parent.lock())
             {
-                auto* rawPtr = p->GraphPtr().get();
+                auto* rawPtr = p->GetGraphPtr().get();
                 output[rawPtr].push_back(
-                    [storedParent = std::move(p), storedValue = dep->Value()]
+                    [storedParent = std::move(p), storedValue = GetInternals(dep).Value()]
                     {
                         NodeId nodeId = storedParent->GetNodeId();
-                        auto& graphPtr = storedParent->GraphPtr();
+                        auto& graphPtr = storedParent->GetGraphPtr();
 
                         graphPtr->AddInput(nodeId,
                             [&storedParent, &storedValue]
@@ -397,11 +401,9 @@ class SignalLinkNode : public SignalNode<S>
 
         std::weak_ptr<SignalLinkNode> parent;
 
-        NodeId nodeId;
-
-        Signal<S> dep;
-
-        Group srcGroup;
+        NodeId      nodeId;
+        Signal<S>   dep;
+        Group       srcGroup;
     };
 
     VirtualOutputNode linkOutput_;

From 88090f769aab1aa086af9d4b3346be1ffb36cba0 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sat, 7 Jan 2017 10:23:46 +0100
Subject: [PATCH 48/75] progress

---
 examples/src/BasicObservers.cpp            |  22 +-
 examples/src/BasicSignals.cpp              |  15 +-
 examples/src/Main.cpp                      | 355 +++++++++++----------
 include/react/Event.h                      |  51 +--
 include/react/Signal.h                     |   2 +-
 include/react/detail/graph/EventNodes.h    | 101 ++----
 include/react/detail/graph/PropagationST.h |  30 +-
 include/react/detail/graph/SignalNodes.h   |  67 ++--
 8 files changed, 313 insertions(+), 330 deletions(-)

diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index ad263a2e..fede6fd0 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -58,17 +58,17 @@ namespace example2
     {
         cout << "Example 2 - Detaching observers manually" << endl;
 
-        Observer obs(
-            [] (EventRange<> in)
-            {
-                for (auto _ : in)
-                    cout << "Triggered!" << endl;
-            },
-            trigger);
-
-        trigger.Emit(); // output: Triggered!
-
-        obs.Cancel();   // Remove the observer
+        {
+            Observer obs(
+                [] (EventRange<> in)
+                {
+                    for (auto _ : in)
+                        cout << "Triggered!" << endl;
+                },
+                trigger);
+
+            trigger.Emit(); // output: Triggered!
+        }
 
         trigger.Emit(); // no output
 
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 6bd6771d..a8b6a60a 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -26,6 +26,9 @@ namespace example1
     string ConcatFunc(string first, string second)
         { return first + string(" ") + second; }
 
+    void PrintFunc(const string& s)
+        { cout  << s << endl; }
+
     // Defines a group.
     // Each group represents a separate dependency graph.
     // Reactives from different groups can not be mixed.
@@ -40,18 +43,14 @@ namespace example1
 
     void Run()
     {
-        cout << "Example 1 - Hello world" << endl;
+        Observer obs{ PrintFunc, bothWords };
 
-        cout  << bothWords.Value() << endl;
+        cout << "Example 1 - Hello world" << endl;
 
         firstWord <<= string("Hello");
 
-        cout << bothWords.Value() << endl;
-
         secondWord <<= string("World");
 
-        cout << bothWords.Value() << endl;
-
         cout << endl;
     }
 }
@@ -150,8 +149,8 @@ namespace example4
         data.Modify([] (vector<string>& data)
             { data.push_back("World"); });
 
-        for (const auto& s : data.Value())
-            cout << s << " ";
+//        for (const auto& s : data.Value())
+//            cout << s << " ";
         cout << endl;
         // output: Hello World
 
diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index cc5fdc31..1ab7a14f 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -17,7 +17,6 @@
 
 using namespace react;
 
-
 template <typename T>
 class GridGraphGenerator
 {
@@ -67,13 +66,13 @@ class GridGraphGenerator
 
                 if (shouldGrow)
                 {
-										auto s = SignalType{ group, function1, *l };
+                    auto s = SignalType{ group, function1, *l };
                     nextBuf->push_back(std::move(s));
                 }
 
                 while (r != curBuf->end())
                 {
-										auto s = SignalType{ group, function2, *l, *r };
+                    auto s = SignalType{ group, function2, *l, *r };
                     nextBuf->push_back(std::move(s));
                     ++nodeCount;
                     ++l; ++r;
@@ -111,38 +110,38 @@ class GridGraphGenerator
 template <typename T>
 T Multiply(T a, T b)
 {
-	return a * b;
+    return a * b;
 }
 
 template <typename T> void PrintValue(T v)
 {
-	printf("Value: %d\n", v);
+    printf("Value: %d\n", v);
 }
 
 template <typename T> void PrintArea(T v)
 {
-	printf("Area: %d\n", v);
+    printf("Area: %d\n", v);
 }
 
 template <typename T> void PrintVolume(T v)
 {
-	printf("Volume: %d\n", v);
+    printf("Volume: %d\n", v);
 }
 
 template <typename T> void PrintEvents(EventRange<T> evts)
 {
 	printf("Processing events...\n");
 
-	for (const auto& e : evts)
-		printf("  Event: %d\n", e);
+    for (const auto& e : evts)
+        printf("  Event: %d\n", e);
 }
 
 template <typename T> void PrintSyncedEvents(EventRange<T> evts, int a, int b)
 {
-	printf("Processing events...\n");
+    printf("Processing events...\n");
 
-	for (const auto& e : evts)
-		printf("  Event: %d, %d, %d\n", e, a, b);
+    for (const auto& e : evts)
+        printf("  Event: %d, %d, %d\n", e, a, b);
 }
 
 template <typename T> bool FilterFunc(T v)
@@ -152,166 +151,179 @@ template <typename T> bool FilterFunc(T v)
 
 template <typename T> T IterFunc1(EventRange<T> evts, T v)
 {
-	return v + 1;
+    return v + 1;
 }
 
 template <typename T> T IterFunc2(EventRange<T> evts, T v, T a1, T a2)
 {
-	return v + 1;
+    return v + 1;
 }
 
-int main2()
+int main()
 {
-	Group group;
+    Group group;
+
+    {
+        // Signals
+        VarSignal<int> x{ group, 0 };
+        VarSignal<int> y{ group, 0 };
+        VarSignal<int> z{ group, 0 };
+
+        Signal<int> area{ Multiply<int>, x, y };
+        Signal<int> volume{ Multiply<int>, area, z };
+
+        Observer areaObs{ PrintArea<int>, area };
+        Observer volumeObs{ PrintVolume<int>, volume };
 
-	{
-		// Signals
-		VarSignal<int> x{ group, 0 };
-		VarSignal<int> y{ group, 0 };
-		VarSignal<int> z{ group, 0 };
+        x.Set(2); // a: 0, v: 0
+        y.Set(2); // a: 4, v: 0
+        z.Set(2); // a: 4, v: 8
 
-		Signal<int> area{ Multiply<int>, x, y };
-		Signal<int> volume{ Multiply<int>, area, z };
+        group.DoTransaction([&]
+        {
+            x.Set(100);
+            y <<= 3;
+            y <<= 4;
+        });
 
-		Observer areaObs{ PrintArea<int>, area };
-		Observer volumeObs{ PrintVolume<int>, volume };
+        // a: 400, v: 800
+    }
 
-		x.Set(2); // a: 0, v: 0
-		y.Set(2); // a: 4, v: 0
-		z.Set(2); // a: 4, v: 8
+    {
+        // Events
+        EventSource<int> button1{ group };
+        EventSource<int> button2{ group };
 
-		group.DoTransaction([&]
-		{
-			x.Set(100);
-			y <<= 3;
-			y <<= 4;
-		});
+        Event<int> anyButton = Merge(button1, button2);
+        Event<int> filtered  = Filter(FilterFunc<int>, anyButton);
 
-		// a: 400, v: 800
-	}
+        Observer eventObs{ PrintEvents<int>, anyButton };
 
-	{
-		// Events
-		EventSource<int> button1{ group };
-		EventSource<int> button2{ group };
+        button1.Emit(1);
+        button2.Emit(2);
 
-		Event<int> anyButton = Merge(button1, button2);
-		Event<int> filtered  = Filter(FilterFunc<int>, anyButton);
+        group.DoTransaction([&]
+        {
+            for (int i=0; i<10; ++i)
+                button1.Emit(42);
+        });
+    }
 
-		Observer eventObs{ PrintEvents<int>, anyButton };
+    {
+        // Dynamic signals
+        VarSignal<int> s1{ group, 10 };
+        VarSignal<int> s2{ group, 22 };
+
+        SignalSlot<int> slot{ s1 };
 
-		button1.Emit(1);
-		button2.Emit(2);
+        Observer areaObs{ PrintValue<int>, slot };
 
-		group.DoTransaction([&]
-		{
-			for (int i=0; i<10; ++i)
-				button1.Emit(42);
-		});
-	}
+        s1.Set(42);
 
-	{
-		// Dynamic signals
-		VarSignal<int> s1{ group, 10 };
-		VarSignal<int> s2{ group, 22 };
+        slot.Set(s2);
 
-		SignalSlot<int> slot{ s1 };
+        s2.Set(667);
+    }
 
-		Observer areaObs{ PrintValue<int>, slot };
+    {
+        // Dynamic events
+        EventSource<int> s1{ group };
+        EventSource<int> s2{ group };
 
-		s1.Set(42);
+        EventSlot<int> slot{ group };
 
-		slot.Set(s2);
+        Observer eventObs{ PrintEvents<int>, anyButton };
 
-		s2.Set(667);
-	}
+        slot.AddInput(s1);
+        slot.AddInput(s2);
+    }
 
-	// Links
-	{
-		Group group1;
-		Group group2;
+    // Links
+    {
+        Group group1;
+        Group group2;
 
-		VarSignal<int> s1{ group1, 10 };
-		VarSignal<int> s2{ group2, 11 };
+        VarSignal<int> s1{ group1, 10 };
+        VarSignal<int> s2{ group2, 11 };
 
-		Signal<int> v{ Multiply<int>, s1, s2 };
+        Signal<int> v{ Multiply<int>, s1, s2 };
 
-		Observer obs{ PrintValue<int>, v };
+        Observer obs{ PrintValue<int>, v };
 
-		s1.Set(555);
+        s1.Set(555);
 
-		std::this_thread::sleep_for(std::chrono::seconds(5));
-	}
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+    }
 
-	{
-		Group group1;
-		Group group2;
+    {
+        Group group1;
+        Group group2;
 
-		VarSignal<int> s1{ group1, 10 };
-		VarSignal<int> s2{ group2, 11 };
+        VarSignal<int> s1{ group1, 10 };
+        VarSignal<int> s2{ group2, 11 };
 
-		EventSource<int> e1{ group1 };
-		EventSource<int> e2{ group2 };
+        EventSource<int> e1{ group1 };
+        EventSource<int> e2{ group2 };
 
-		auto hold = Hold(group1, 0, e1);
+        auto hold = Hold(group1, 0, e1);
 
-		auto merged = Merge(group2, e1, e2);
+        auto merged = Merge(group2, e1, e2);
 
-		auto joined1 = Join(e1, e2);
-		auto joined2 = Join(group1, e1, e2);
+        auto joined1 = Join(e1, e2);
+        auto joined2 = Join(group1, e1, e2);
 
-		Observer eventObs1{ PrintEvents<int>, merged };
-		Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
+        Observer eventObs1{ PrintEvents<int>, merged };
+        Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
 
-		e1.Emit(222);
+        e1.Emit(222);
 
-		std::this_thread::sleep_for(std::chrono::seconds(5));
-	}
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+    }
 
-	{
-		Group group1;
-		Group group2;
+    {
+        Group group1;
+        Group group2;
 
-		VarSignal<int> s1{ group1, 10 };
-		VarSignal<int> s2{ group2, 11 };
+        VarSignal<int> s1{ group1, 10 };
+        VarSignal<int> s2{ group2, 11 };
 
-		EventSource<int> e1{ group1 };
-		EventSource<int> e2{ group2 };
+        EventSource<int> e1{ group1 };
+        EventSource<int> e2{ group2 };
 
-		auto hold1 = Hold(group1, 0, e1);
-		auto hold2 = Hold(0, e1);
+        auto hold1 = Hold(group1, 0, e1);
+        auto hold2 = Hold(0, e1);
 
-		auto monitor1 = Monitor(group1, s1);
-		auto monitor2 = Monitor(s1);
+        auto monitor1 = Monitor(group1, s1);
+        auto monitor2 = Monitor(s1);
 
-		auto snapshot1 = Snapshot(group1, s1, e1);
-		auto snapshot2 = Snapshot(s1, e1);
+        auto snapshot1 = Snapshot(group1, s1, e1);
+        auto snapshot2 = Snapshot(s1, e1);
 
-		auto pulse1 = Pulse(group1, s1, e1);
-		auto pulse2 = Pulse(s1, e1);
+        auto pulse1 = Pulse(group1, s1, e1);
+        auto pulse2 = Pulse(s1, e1);
 
-		auto merged = Merge(group2, e1, e2);
+        auto merged = Merge(group2, e1, e2);
 
-		auto joined1 = Join(e1, e2);
-		auto joined2 = Join(group1, e1, e2);
+        auto joined1 = Join(e1, e2);
+        auto joined2 = Join(group1, e1, e2);
 
-		auto iter1 = Iterate<int>(group, 0, IterFunc1<int>, e1);
-		auto iter2 = Iterate<int>(0, IterFunc1<int>, e1);
+        auto iter1 = Iterate<int>(group, 0, IterFunc1<int>, e1);
+        auto iter2 = Iterate<int>(0, IterFunc1<int>, e1);
 
-		auto iter3 = Iterate<int>(group, 0, IterFunc2<int>, e1, s1, s2);
-		auto iter4 = Iterate<int>(0, IterFunc2<int>, e1, s1, s2);
+        auto iter3 = Iterate<int>(group, 0, IterFunc2<int>, e1, s1, s2);
+        auto iter4 = Iterate<int>(0, IterFunc2<int>, e1, s1, s2);
 
-		Observer eventObs{ PrintEvents<int>, merged };
-		Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
+        Observer eventObs{ PrintEvents<int>, merged };
+        Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
 
-		e1.Emit(222);
+        e1.Emit(222);
 
-		std::this_thread::sleep_for(std::chrono::seconds(5));
+        std::this_thread::sleep_for(std::chrono::seconds(5));
 
-		GridGraphGenerator<int> grid;
-	}
+        GridGraphGenerator<int> grid;
+    }
 
-	return 0;
+    return 0;
 }
 
 
@@ -324,39 +336,39 @@ int main2()
 
 
 
-int main()
+int main2()
 {
-	Group group;
+    Group group;
 
-	VarSignal<int> in{ group, 1 };
-	Signal<int> in2 = in;
+    VarSignal<int> in{ group, 1 };
+    Signal<int> in2 = in;
 
-	GridGraphGenerator<int> generator;
+    GridGraphGenerator<int> generator;
 
-	generator.inputSignals.push_back(in2);
+    generator.inputSignals.push_back(in2);
 
-	generator.widths.push_back(100);
-	generator.widths.push_back(1);
+    generator.widths.push_back(100);
+    generator.widths.push_back(1);
 
-	int updateCount = 0;
+    int updateCount = 0;
 
-	generator.function1 = [&] (int a) { ++updateCount; return a; };
-	generator.function2 = [&] (int a, int b) { ++updateCount; return a + b; };
+    generator.function1 = [&] (int a) { ++updateCount; return a; };
+    generator.function2 = [&] (int a, int b) { ++updateCount; return a + b; };
 
-	generator.Generate(group);
+    generator.Generate(group);
 
-	updateCount = 0;
+    updateCount = 0;
 
-	auto t0 = tbb::tick_count::now();
-	for (int i = 0; i < 10000; i++)
-		in <<= 10 + i;
-	auto t1 = tbb::tick_count::now();
+    auto t0 = tbb::tick_count::now();
+    for (int i = 0; i < 10000; i++)
+	    in <<= 10 + i;
+    auto t1 = tbb::tick_count::now();
 
-	double d = (t1 - t0).seconds();
-	printf("updateCount %d\n", updateCount);
-	printf("Time %g\n", d);
+    double d = (t1 - t0).seconds();
+    printf("updateCount %d\n", updateCount);
+    printf("Time %g\n", d);
 
-	return 0;
+    return 0;
 }
 
 
@@ -371,47 +383,46 @@ int main()
 
 
 
+/*
 
-
-
-/*int main2()
+int main7()
 {
-	Group group1;
-	Group group2;
-	Group group3;
+    Group group1;
+    Group group2;
+    Group group3;
 
-	VarSignal<int> x{ 0, group1 };
-	VarSignal<int> y{ 0, group2 };
-	VarSignal<int> z{ 0, group3 };
+    VarSignal<int> x{ group1, 0 };
+    VarSignal<int> y{ group2, 0 };
+    VarSignal<int> z{ group3, 0 };
 
-	Signal<int> area{ Multiply<int>, x, y };
-	Signal<int> volume{ Multiply<int>, area, z };
+    Signal<int> area{ Multiply<int>, x, y };
+    Signal<int> volume{ Multiply<int>, area, z };
 
-	Observer obs{ PrintAreaAndVolume, area, volume };
+    Observer obs{ PrintAreaAndVolume, area, volume };
 
-	Signal<vector<int>> volumeHistory = Iterate<vector<int>>( vector<int>{ }, PushToVector, Monitor(volume));
+    Signal<vector<int>> volumeHistory = Iterate<vector<int>>( vector<int>{ }, PushToVector, Monitor(volume));
 
-	x <<= 2;
-	y <<= 2;
-	z <<= 2;
+    x <<= 2;
+    y <<= 2;
+    z <<= 2;
 
-	group.DoTransaction([&]
-	{
-		x <<= 100;
-		y <<= 200;
-		z <<= 300;
-	});
+    group.DoTransaction([&]
+    {
+        x <<= 100;
+        y <<= 200;
+        z <<= 300;
+    });
 
-	obs.Cancel();
+    obs.Cancel();
 
-	x <<= 42;
+    x <<= 42;
 
-	printf("History:\n");
-	for (auto t : volumeHistory.Value())
-		printf("%d ", t);
-	printf("\n");
+    printf("History:\n");
+    for (auto t : volumeHistory.Value())
+        printf("%d ", t);
+    printf("\n");
 
-	return 0;
+    return 0;
 }
 
 
@@ -421,14 +432,16 @@ int main3()
     using namespace react;
 
     Group group1;
-		Group group2;
+    Group group2;
 
     auto sig1 = VarSignal<int>( 10, group1 );
 
     auto link1 = SignalLink<int>( sig1, group2 );
-		auto link2 = SignalLink<int>( sig1, group2 );
+    auto link2 = SignalLink<int>( sig1, group2 );
 
-		sig1.Set(10);
+    sig1.Set(10);
 
     return 0;
-}*/
\ No newline at end of file
+}
+
+*/
\ No newline at end of file
diff --git a/include/react/Event.h b/include/react/Event.h
index 01c284c6..5a7fc42e 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -239,37 +239,37 @@ class EventSlot : public Event<E>
     EventSlot(EventSlot&&) = default;
     EventSlot& operator=(EventSlot&&) = default;
 
-    // Construct with explicit group
-    EventSlot(const Group& group, const Event<E>& input) :
-        EventSlot::Event( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
+    // Construct emtpy slot
+    EventSlot(const Group& group) :
+        EventSlot::Event( REACT_IMPL::CtorTag{ }, CreateSlotNode(group) )
         { }
 
-    // Construct with implicit group
-    EventSlot(const Event<E>& input) :
-        EventSlot::Event( REACT_IMPL::CtorTag{ }, CreateSlotNode(input.GetGroup(), input) )
-        { }
+    void Add(const Event<E>& input)
+        { AddInput(input); }
 
-    void Set(const Event<E>& newInput)
-        { SetInput(newInput); }
+    void Remove(const Event<E>& input)
+        { RemoveInput(input); }
 
-    void operator<<=(const Event<E>& newInput)
-        { SetInput(newInput); }
+    void RemoveAll()
+        { RemoveAllInputs(); }
 
 protected:
-    auto CreateSlotNode(const Group& group, const Event<E>& input) -> decltype(auto)
+    auto CreateSlotNode(const Group& group) -> decltype(auto)
     {
         using REACT_IMPL::EventSlotNode;
-        return std::make_shared<EventSlotNode<E>>(group, SameGroupOrLink(input));
+        return std::make_shared<EventSlotNode<E>>(group);
     }
 
 private:
-    void SetInput(const Event<E>& newInput)
+    void AddInput(const Event<E>& input)
     {
+        SameGroupOrLink(input)
+
         using REACT_IMPL::NodeId;
         using REACT_IMPL::ReactiveGraph;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
 
-        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->NodePtr().get());
+        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = NodePtr()->GraphPtr();
@@ -292,21 +292,24 @@ class EventLink : public Event<E>
 
     // Construct with explicit group
     EventLink(const Group& group, const Event<E>& input) :
-        EventLink::Event( REACT_IMPL::CtorTag{ }, CreateLinkNode(group, input) )
-        { }
-
-    // Construct with implicit group
-    explicit EventLink(const Event<E>& input) :
-        EventLink::Event( REACT_IMPL::CtorTag{ }, CreateLinkNode(input.GetGroup(), input) )
+        EventLink::Event( REACT_IMPL::CtorTag{ }, GetOrCreateLinkNode(group, input) )
         { }
 
 protected:
-    static auto CreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
+    static auto GetOrCreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::EventLinkNode;
 
-        auto node = std::make_shared<EventLinkNode<E>>(group, input);
-        node->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ node });
+        const void* inputPtr = GetInternals(input.GetGroup()).GetGraphPtr().get();
+        const void* targetPtr = GetInternals(group).GetGraphPtr().get();
+
+        {
+
+        }
+
+        auto nodePtr = std::make_shared<EventLinkNode<E>>(group, input);
+        auto weakPtr = 
+        nodePtr->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ nodePtr });
         return node;
     }
 };
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 10ed71f8..22e237fc 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -244,7 +244,7 @@ class SignalSlot : public Signal<S>
     static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::SignalSlotNode;
-        return std::make_shared<SignalSlotNode<S>>(group, input);
+        return std::make_shared<SignalSlotNode<S>>(group, SameGroupOrLink(group, input));
     }
 
 private:
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index f720fc18..27d81a41 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -236,23 +236,21 @@ class EventSlotNode : public EventStreamNode<E>
 {
 public:
     EventSlotNode(const Group& group) :
-        EventSlotNode::EventStreamNode( group ),
-        slotInput_( *this )
+        EventSlotNode::EventStreamNode( group )
     {
-        slotInput_.nodeId = GraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
+        inputNodeId_ = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
         this->RegisterMe();
 
-        this->AttachToMe(slotInput_.nodeId);
-        //this->AttachToMe(GetInternals(dep).GetNodeId());
+        this->AttachToMe(inputNodeId_);
     }
 
     ~EventSlotNode()
     {
-        this->DetachFromMe(GetInternals(slotInput_.dep).GetNodeId());
-        this->DetachFromMe(slotInput_.nodeId);
+        RemoveAllInputs();
+        this->DetachFromMe(inputNodeId_);
 
         this->UnregisterMe();
-        GraphPtr()->UnregisterNode(slotInput_.nodeId);
+        GetGraphPtr()->UnregisterNode(inputNodeId_);
     }
 
     virtual const char* GetNodeType() const override
@@ -263,7 +261,11 @@ class EventSlotNode : public EventStreamNode<E>
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        this->Events().insert(this->Events().end(), slotInput_.dep->Events().begin(), slotInput_.dep->Events().end());
+        for (const auto& e : deps_)
+        {
+            const auto& events = GetInternals(e).Events();
+            this->Events().insert(this->Events().end(), events.begin(), events.end());
+        }
 
         slotInput_.dep->DecrementPendingSuccessorCount();
 
@@ -278,89 +280,54 @@ class EventSlotNode : public EventStreamNode<E>
         }
     }
 
-    void AddInput(const Event<E>>& input)
+    void AddInput(const Event<E>& input)
     {
-        auto& newDeps = slotInput_.newDeps;
-
-        for (auto& e : newDeps)
+        auto it = std::find(inputs_.begin(), inputs_.end(), input);
+        if (it == inputs_.end())
         {
-            if (e.second != input)
-                continue;
-
-            // Earlier remove is overridden by later add.
-            if (e.first == false)
-                e.first = true;
-            
-            // Either element was already added, or remove has been overridden. Nothing more to do.
-            return;
+            inputs_.push_back(input);
+            this->AttachToMe(GetInternals(input).GetNodeId());
         }
-
-        newDeps.emplace_back(true, input);
     }
 
     void RemoveInput(const Event<E>& input)
     {
-        auto& newDeps = slotInput_.newDeps;
-
-        for (auto& e : newDeps)
+        auto it = std::find(inputs_.begin(), inputs_.end(), input);
+        if (it != inputs_.end())
         {
-            if (e.second != input)
-                continue;
-
-            // Earlier add is overridden by later remove.
-            if (e.first == true)
-                e.first = false;
-            
-            // Either element was already removed, or add has been overridden. Nothing more to do.
-            return;
+            inputs_.erase(it);
+            this->DetachFromMe(GetInternals(input).GetNodeId());
         }
+    }
+
+    void RemoveAllInputs()
+    {
+        for (const auto& e : inputs_)
+            this->DetachFromMe(GetInternals(e).GetNodeId());
 
-        newDeps.emplace_back(false, input);
+        inputs_.clear();
     }
 
     NodeId GetInputNodeId() const
-        { return slotInput_.nodeId; }
+        { return inputNodeId_; }
 
 private:        
     struct VirtualInputNode : public IReactiveNode
     {
-        VirtualInputNode(EventSlotNode& parentIn, const Event<E>& depIn) :
-            parent( parentIn ),
-            dep( depIn )
-            { }
-
         virtual const char* GetNodeType() const override
-            { return "EventSlotVirtualInput"; }
+            { return "EventSlotInput"; }
 
         virtual int GetDependencyCount() const override
             { return 0; }
 
         virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
-        {
-            if (dep != newDep)
-            {
-                parent.DynamicDetachFromMe(dep->GetNodeId(), 0);
-                parent.DynamicAttachToMe(newDep->GetNodeId(), 0);
-
-                dep = std::move(newDep);
-                return UpdateResult::changed;
-            }
-            else
-            {
-                newDep.reset();
-                return UpdateResult::unchanged;
-            }
-        }
-
-        EventSlotNode& parent;
-
-        NodeId nodeId;
-
-        std::vector<Event<E>> deps;
-        std::vector<std::pair<bool /* isAdded */, Event<E>>> newDeps;
+            { return UpdateResult::changed; }
     };
 
-    VirtualInputNode slotInput_;
+    std::vector<Event<E>> inputs_;
+
+    NodeId              inputNodeId_;
+    VirtualInputNode    slotInput_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index 814fc94c..c9cb6dfc 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -26,6 +26,33 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
+template <typename K>
+class PtrCache
+{
+public:
+    void Add(const K& key, const std::shared_ptr<void>& ptr)
+    {
+        auto res = map1_.insert(key, ptr);
+        if (res.first == true)
+        {
+            map2_.insert(ptr , res.second);
+            return true;
+        }
+        
+    }
+
+    void Remove(const std::shared_ptr<void>& ptr)
+    {
+        map2_.remove();
+    }
+
+private:
+    std::mutex  lock_;
+
+    std::map<K, std::weak_ptr<void>> map1_;
+    std::unordered_map<void*, std::map::iterator> map2_;
+};
+
 class ReactiveGraph;
 
 class TransactionQueue
@@ -94,9 +121,6 @@ class ReactiveGraph
     void OnNodeAttach(NodeId node, NodeId parentId);
     void OnNodeDetach(NodeId node, NodeId parentId);
 
-    void OnDynamicNodeAttach(NodeId node, NodeId parentId, TurnId turnId);
-    void OnDynamicNodeDetach(NodeId node, NodeId parentId, TurnId turnId);
-
     template <typename F>
     void AddInput(NodeId nodeId, F&& inputCallback);
 
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index d137c506..607746ea 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -221,24 +221,22 @@ class SignalSlotNode : public SignalNode<S>
 public:
     SignalSlotNode(const Group& group, const Signal<S>& dep) :
         SignalSlotNode::SignalNode( group, GetInternals(dep).Value() ),
-        slotInput_( *this, dep )
+        input_( dep )
     {
-        slotInput_.nodeId = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
+        inputNodeId_ = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
         this->RegisterMe();
 
-        this->AttachToMe(slotInput_.nodeId);
+        this->AttachToMe(inputNodeId_);
         this->AttachToMe(GetInternals(dep).GetNodeId());
     }
 
     ~SignalSlotNode()
     {
-        const auto& depNodePtr = GetInternals(slotInput_.dep).GetNodePtr();
-
-        this->DetachFromMe(depNodePtr->GetNodeId());
-        this->DetachFromMe(slotInput_.nodeId);
+        this->DetachFromMe(GetInternals(input_).GetNodeId());
+        this->DetachFromMe(inputNodeId_);
 
         this->UnregisterMe();
-        GetGraphPtr()->UnregisterNode(slotInput_.nodeId);
+        GetGraphPtr()->UnregisterNode(inputNodeId_);
     }
 
     virtual const char* GetNodeType() const override
@@ -249,11 +247,9 @@ class SignalSlotNode : public SignalNode<S>
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        const auto& depNodePtr = GetInternals(slotInput_.dep).GetNodePtr();
-
-        if (! (this->Value() == depNodePtr->Value()))
+        if (! (this->Value() == GetInternals(input_).Value()))
         {
-            this->Value() = depNodePtr->Value();
+            this->Value() = GetInternals(input_).Value();
             return UpdateResult::changed;
         }
         else
@@ -264,21 +260,21 @@ class SignalSlotNode : public SignalNode<S>
 
     void SetInput(const Signal<S>& newInput)
     {
-        slotInput_.isChanged = true;
+        if (newInput == input_)
+            return;
+
+        this->DetachFromMe(GetInternals(input_).GetNodeId());
+        this->AttachToMe(GetInternals(newInput).GetNodeId());
+
+        input_ = newInput;
     }
-        { slotInput_.newDep = newInput; }
 
     NodeId GetInputNodeId() const
-        { return slotInput_.nodeId; }
+        { return inputNodeId_; }
 
 private:        
     struct VirtualInputNode : public IReactiveNode
     {
-        VirtualInputNode(SignalSlotNode& parentIn, const Signal<S>& depIn) :
-            parent( parentIn ),
-            dep( depIn )
-            { }
-
         virtual const char* GetNodeType() const override
             { return "SignalSlotInput"; }
 
@@ -286,33 +282,14 @@ class SignalSlotNode : public SignalNode<S>
             { return 0; }
 
         virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
-        {
-            if (dep != newDep)
-            {
-                const auto& depNodePtr = GetInternals(dep).GetNodePtr();
-                const auto& newDepNodePtr = GetInternals(newDep).GetNodePtr();
-
-                parent.DynamicDetachFromMe(depNodePtr->GetNodeId(), 0);
-                parent.DynamicAttachToMe(newDepNodePtr->GetNodeId(), 0);
-
-                dep = std::move(newDep);
-                return UpdateResult::changed;
-            }
-            else
-            {
-                return UpdateResult::unchanged;
-            }
-        }
-
-        SignalSlotNode& parent;
-
-        NodeId nodeId;
-
-        Signal<S>   dep;
-        bool        isChanged = false;
+            { return UpdateResult::changed; }
     };
 
-    VirtualInputNode slotInput_;
+    Signal<S> input_;
+
+    NodeId              inputNodeId_;
+    VirtualInputNode    slotInput_;
+    
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////

From d24b490af8f866ad954e1d3413c1b7a00791d58e Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sat, 7 Jan 2017 22:17:52 +0100
Subject: [PATCH 49/75] progress

---
 include/react/Event.h                      | 59 +++++++++++++++----
 include/react/detail/graph/EventNodes.h    |  6 +-
 include/react/detail/graph/GraphBase.h     |  6 --
 include/react/detail/graph/PropagationST.h | 66 ++++++++++++++--------
 4 files changed, 93 insertions(+), 44 deletions(-)

diff --git a/include/react/Event.h b/include/react/Event.h
index 5a7fc42e..7020a638 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -263,17 +263,41 @@ class EventSlot : public Event<E>
 private:
     void AddInput(const Event<E>& input)
     {
-        SameGroupOrLink(input)
+        using REACT_IMPL::NodeId;
+        using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
+
+        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());
+
+        NodeId nodeId = castedPtr->GetInputNodeId();
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
+        graphPtr->AddInput(nodeId, [castedPtr, &input] { castedPtr->AddInput(input); });
+    }
+
+    void RemoveInput(const Event<E>& input)
+    {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::ReactiveGraph;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
 
         SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetInputNodeId();
-        auto& graphPtr = NodePtr()->GraphPtr();
-        graphPtr->AddInput(nodeId, [castedPtr, &newInput] { castedPtr->SetInput(PrivateNodeInterface::NodePtr(newInput)); });
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
+
+        graphPtr->AddInput(nodeId, [castedPtr, &input] { castedPtr->RemoveInput(input); });
+    }
+
+    void RemoveAllInputs()
+    {
+        using REACT_IMPL::NodeId;
+        using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
+
+        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());
+
+        NodeId nodeId = castedPtr->GetInputNodeId();
+        auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
+
+        graphPtr->AddInput(nodeId, [castedPtr] { castedPtr->RemoveAllInputs(); });
     }
 };
 
@@ -295,22 +319,33 @@ class EventLink : public Event<E>
         EventLink::Event( REACT_IMPL::CtorTag{ }, GetOrCreateLinkNode(group, input) )
         { }
 
+    ~EventLink()
+    {
+        auto nodePtr = GetNodePtr();
+    }
+
 protected:
     static auto GetOrCreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::EventLinkNode;
 
-        const void* inputPtr = GetInternals(input.GetGroup()).GetGraphPtr().get();
-        const void* targetPtr = GetInternals(group).GetGraphPtr().get();
+        auto targetGraphPtr = GetInternals(group).GetGraphPtr();
+        
+        void* k1 = GetInternals(input.GetGroup()).GetGraphPtr().get();
+        void* k2 = GetInternals(input).GetNodePtr().get();
 
-        {
+        auto& linkCache = targetGraphPtr->GetLinkCache();
 
-        }
+        auto nodePtr = linkCache.LookupOrCreate<EventLinkNode<E>>(
+            { k1, k2 },
+            [&]
+            {
+                auto nodePtr = std::make_shared<EventLinkNode<E>>(group, input);
+                nodePtr->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ nodePtr });
+                return nodePtr;
+            });
 
-        auto nodePtr = std::make_shared<EventLinkNode<E>>(group, input);
-        auto weakPtr = 
-        nodePtr->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ nodePtr });
-        return node;
+        return nodePtr;
     }
 };
 
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 27d81a41..2ccccca3 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -261,13 +261,13 @@ class EventSlotNode : public EventStreamNode<E>
 
     virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
     {
-        for (const auto& e : deps_)
+        for (auto& e : inputs_)
         {
             const auto& events = GetInternals(e).Events();
             this->Events().insert(this->Events().end(), events.begin(), events.end());
-        }
 
-        slotInput_.dep->DecrementPendingSuccessorCount();
+            GetInternals(e).DecrementPendingSuccessorCount();
+        }
 
         if (! this->Events().empty())
         {
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/graph/GraphBase.h
index 43f58f89..65f8d1f7 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/graph/GraphBase.h
@@ -83,12 +83,6 @@ class NodeBase : public IReactiveNode
     void DetachFromMe(NodeId otherNodeId)
         { GetGraphPtr()->OnNodeDetach(nodeId_, otherNodeId); }
 
-    void DynamicAttachToMe(NodeId otherNodeId, TurnId turnId)
-        { GetGraphPtr()->OnDynamicNodeAttach(nodeId_, otherNodeId, turnId); }
-
-    void DynamicDetachFromMe(NodeId otherNodeId, TurnId turnId)
-        { GetGraphPtr()->OnDynamicNodeDetach(nodeId_, otherNodeId, turnId); }
-
 private:
     NodeId nodeId_;
 
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index c9cb6dfc..fd2640fd 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -16,6 +16,8 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
+#include <map>
+#include <mutex>
 
 #include <tbb/concurrent_queue.h>
 #include <tbb/task.h>
@@ -30,27 +32,49 @@ template <typename K>
 class PtrCache
 {
 public:
-    void Add(const K& key, const std::shared_ptr<void>& ptr)
+    template <typename V, typename F>
+    std::shared_ptr<V> LookupOrCreate(const K& key, F&& createFunc)
     {
-        auto res = map1_.insert(key, ptr);
-        if (res.first == true)
+        std::lock_guard<std::mutex> scopedLock(mutex_);
+
+        auto it = map1_.find(key);
+
+        if (it != map1_.end())
         {
-            map2_.insert(ptr , res.second);
-            return true;
+            if (auto ptr = it->second.lock())
+            {
+                return std::static_pointer_cast<V>(ptr);
+            }
         }
-        
+
+        std::shared_ptr<V> v = createFunc();
+        auto res = map1_.insert({ key, std::weak_ptr<void>{ v } });
+        map2_[v.get()] = res.first;
+        return v;
     }
 
-    void Remove(const std::shared_ptr<void>& ptr)
+    template <typename V>
+    void Erase(const std::shared_ptr<V>& ptr)
     {
-        map2_.remove();
+        std::lock_guard<std::mutex> scopedLock(mutex_);
+
+        auto it = map2_.find((void*)ptr.get());
+
+        if (it != map2_.end())
+        {
+            map1_.erase(it->second);
+            map2_.erase(it);
+        }
     }
 
 private:
-    std::mutex  lock_;
+    std::mutex  mutex_;
+
+    using Map1Type = std::map<K, std::weak_ptr<void>>;
+    using Map2Type = std::unordered_map<void*, typename Map1Type::iterator>;
 
-    std::map<K, std::weak_ptr<void>> map1_;
-    std::unordered_map<void*, std::map::iterator> map2_;
+    Map1Type map1_;
+    Map2Type map2_;
 };
 
 class ReactiveGraph;
@@ -115,6 +139,8 @@ class TransactionQueue
 class ReactiveGraph
 {
 public:
+    using LinkCacheType = PtrCache<std::pair<void*, void*>>;
+
     NodeId RegisterNode(IReactiveNode* nodePtr, NodeCategory category);
     void UnregisterNode(NodeId nodeId);
 
@@ -129,6 +155,9 @@ class ReactiveGraph
 
     template <typename F>
     void EnqueueTransaction(TransactionFlags flags, F&& transactionCallback);
+    
+    LinkCacheType& GetLinkCache()
+        { return linkCache_; }
 
 private:
     struct NodeData
@@ -189,7 +218,9 @@ class ReactiveGraph
     TopoQueue           scheduledNodes_;
     IndexMap<NodeData>  nodeData_;
     std::vector<NodeId> changedInputs_;
-    LinkOutputMap				scheduledLinkOutputs_;
+    LinkOutputMap       scheduledLinkOutputs_;
+
+    LinkCacheType       linkCache_;
 
     bool isTransactionActive_ = false;
 };
@@ -202,7 +233,6 @@ NodeId ReactiveGraph::RegisterNode(IReactiveNode* nodePtr, NodeCategory category
 void ReactiveGraph::UnregisterNode(NodeId nodeId)
 {
     nodeData_.Remove(nodeId);
-
 }
 
 void ReactiveGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
@@ -224,16 +254,6 @@ void ReactiveGraph::OnNodeDetach(NodeId nodeId, NodeId parentId)
     successors.erase(std::find(successors.begin(), successors.end(), nodeId));
 }
 
-void ReactiveGraph::OnDynamicNodeAttach(NodeId nodeId, NodeId parentId, TurnId turnId)
-{
-    OnNodeAttach(nodeId, parentId);
-}
-
-void ReactiveGraph::OnDynamicNodeDetach(NodeId nodeId, NodeId parentId, TurnId turnId)
-{
-    OnNodeDetach(nodeId, parentId);
-}
-
 template <typename F>
 void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
 {

From 20f0149bdee34cc3fa68a1908b4b950842f45e40 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Sun, 8 Jan 2017 01:07:01 +0100
Subject: [PATCH 50/75] done with link cache

---
 examples/src/Main.cpp                      | 48 ++++++++++++++++++++--
 include/react/Event.h                      | 18 +++-----
 include/react/Signal.h                     | 33 +++++++++------
 include/react/detail/graph/EventNodes.h    |  3 ++
 include/react/detail/graph/PropagationST.h |  4 +-
 include/react/detail/graph/SignalNodes.h   |  3 ++
 6 files changed, 79 insertions(+), 30 deletions(-)

diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 1ab7a14f..5720dcf1 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -159,7 +159,7 @@ template <typename T> T IterFunc2(EventRange<T> evts, T v, T a1, T a2)
     return v + 1;
 }
 
-int main()
+int main1()
 {
     Group group;
 
@@ -232,10 +232,13 @@ int main()
 
         EventSlot<int> slot{ group };
 
-        Observer eventObs{ PrintEvents<int>, anyButton };
+        Observer eventObs{ PrintEvents<int>, slot };
+
+        slot.Add(s1);
+        slot.Add(s2);
 
-        slot.AddInput(s1);
-        slot.AddInput(s2);
+        slot.Remove(s1);
+        slot.RemoveAll();
     }
 
     // Links
@@ -327,7 +330,44 @@ int main()
 }
 
 
+int main()
+{
+    Group group;
+
+    Group extGroup;
+
+    // Dynamic events
+    EventSource<int> s1{ group };
+    EventSource<int> s2{ group };
+    EventSource<int> s3{ extGroup };
+    //EventSource<int> s4{ extGroup };
+
+    EventSlot<int> slot{ group };
+
+    Observer eventObs{ PrintEvents<int>, slot };
+    //Observer extObs{ PrintEvents<int>, link1 };
+
+    //slot.Add(s1);
+    //slot.Add(s2);
 
+    group.DoTransaction([&]
+    {
+        s1.Emit(1);
+        s2.Emit(2);
+
+
+        slot.Add(s3);
+        slot.Add(s3);
+        slot.Add(s3);
+        slot.Add(s3);
+    });
+
+    s3.Emit(3);
+
+    std::this_thread::sleep_for(std::chrono::seconds(5));
+
+    return 0;
+}
 
 
 
diff --git a/include/react/Event.h b/include/react/Event.h
index 7020a638..5d97dfff 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -271,7 +271,7 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr, &input] { castedPtr->AddInput(input); });
+        graphPtr->AddInput(nodeId, [this, castedPtr, &input] { castedPtr->AddInput(SameGroupOrLink(GetGroup(), input)); });
     }
 
     void RemoveInput(const Event<E>& input)
@@ -284,7 +284,7 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr, &input] { castedPtr->RemoveInput(input); });
+        graphPtr->AddInput(nodeId, [this, castedPtr, &input] { castedPtr->RemoveInput(SameGroupOrLink(GetGroup(), input)); });
     }
 
     void RemoveAllInputs()
@@ -314,28 +314,22 @@ class EventLink : public Event<E>
     EventLink(EventLink&&) = default;
     EventLink& operator=(EventLink&&) = default;
 
-    // Construct with explicit group
+    // Construct with group
     EventLink(const Group& group, const Event<E>& input) :
         EventLink::Event( REACT_IMPL::CtorTag{ }, GetOrCreateLinkNode(group, input) )
         { }
 
-    ~EventLink()
-    {
-        auto nodePtr = GetNodePtr();
-    }
-
 protected:
     static auto GetOrCreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::EventLinkNode;
 
-        auto targetGraphPtr = GetInternals(group).GetGraphPtr();
+        auto& targetGraphPtr = GetInternals(group).GetGraphPtr();
+        auto& linkCache = targetGraphPtr->GetLinkCache();
         
         void* k1 = GetInternals(input.GetGroup()).GetGraphPtr().get();
         void* k2 = GetInternals(input).GetNodePtr().get();
 
-        auto& linkCache = targetGraphPtr->GetLinkCache();
-
         auto nodePtr = linkCache.LookupOrCreate<EventLinkNode<E>>(
             { k1, k2 },
             [&]
@@ -495,7 +489,7 @@ static Event<E> SameGroupOrLink(const Group& targetGroup, const Event<E>& dep)
     if (dep.GetGroup() == targetGroup)
         return dep;
     else
-        return EventLink<E>( targetGroup, dep );
+        return EventLink<E>{ targetGroup, dep };
 }
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/Signal.h b/include/react/Signal.h
index 22e237fc..a429f34b 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -258,7 +258,7 @@ class SignalSlot : public Signal<S>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr, &newInput] { castedPtr->SetInput(newInput); });
+        graphPtr->AddInput(nodeId, [this, castedPtr, &newInput] { castedPtr->SetInput(SameGroupOrLink(GetGroup(), newInput)); });
     }
 };
 
@@ -275,24 +275,33 @@ class SignalLink : public Signal<S>
     SignalLink(SignalLink&&) = default;
     SignalLink& operator=(SignalLink&&) = default;
 
-    // Construct with explicit group
+    // Construct with group
     SignalLink(const Group& group, const Signal<S>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(group, input) )
-        { }
-
-    // Construct with implicit group
-    explicit SignalLink(const Signal<S>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, CreateLinkNode(input.GetGroup(), input) )
+        SignalLink::Signal( REACT_IMPL::CtorTag{ }, GetOrCreateLinkNode(group, input) )
         { }
 
 protected:
-    static auto CreateLinkNode(const Group& group, const Signal<S>& input) -> decltype(auto)
+    static auto GetOrCreateLinkNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::SignalLinkNode;
 
-        auto node = std::make_shared<SignalLinkNode<S>>(group, input);
-        node->SetWeakSelfPtr(std::weak_ptr<SignalLinkNode<S>>{ node });
-        return node;
+        auto targetGraphPtr = GetInternals(group).GetGraphPtr();
+        
+        void* k1 = GetInternals(input.GetGroup()).GetGraphPtr().get();
+        void* k2 = GetInternals(input).GetNodePtr().get();
+
+        auto& linkCache = targetGraphPtr->GetLinkCache();
+
+        auto nodePtr = linkCache.LookupOrCreate<SignalLinkNode<S>>(
+            { k1, k2 },
+            [&]
+            {
+                auto nodePtr = std::make_shared<SignalLinkNode<S>>(group, input);
+                nodePtr->SetWeakSelfPtr(std::weak_ptr<SignalLinkNode<S>>{ nodePtr });
+                return nodePtr;
+            });
+
+        return nodePtr;
     }
 };
 
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/graph/EventNodes.h
index 2ccccca3..e216b4b5 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/graph/EventNodes.h
@@ -562,6 +562,9 @@ class EventLinkNode : public EventStreamNode<E>
 
     ~EventLinkNode()
     {
+        auto& linkCache = GetGraphPtr()->GetLinkCache();
+        linkCache.Erase(this);
+
         this->UnregisterMe();
     }
 
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index fd2640fd..d1cead73 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -54,11 +54,11 @@ class PtrCache
     }
 
     template <typename V>
-    void Erase(const std::shared_ptr<V>& ptr)
+    void Erase(V* ptr)
     {
         std::lock_guard<std::mutex> scopedLock(mutex_);
 
-        auto it = map2_.find((void*)ptr.get());
+        auto it = map2_.find((void*)ptr);
 
         if (it != map2_.end())
         {
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/graph/SignalNodes.h
index 607746ea..268faf7c 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/graph/SignalNodes.h
@@ -308,6 +308,9 @@ class SignalLinkNode : public SignalNode<S>
 
     ~SignalLinkNode()
     {
+        auto& linkCache = GetGraphPtr()->GetLinkCache();
+        linkCache.Erase(this);
+
         this->UnregisterMe();
     }
 

From 32fe91e6bcaa01556ddde119e5fc70e2c5f65756 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 23 Jan 2017 20:37:48 +0100
Subject: [PATCH 51/75] progress

---
 include/react/Group.h                      |   6 +-
 include/react/common/Containers.h          | 267 +++++----------------
 include/react/detail/graph/PropagationST.h |   5 +-
 include/react/engine/PulsecountEngine.h    | 151 ------------
 include/react/engine/SubtreeEngine.h       | 198 ---------------
 include/react/engine/ToposortEngine.h      | 214 -----------------
 include/react/logging/EventLog.h           | 100 --------
 include/react/logging/EventRecords.h       | 263 --------------------
 include/react/logging/Logging.h            |  31 ---
 project/msvc/CppReact.vcxproj              |   3 -
 project/msvc/CppReact.vcxproj.filters      |  12 -
 11 files changed, 71 insertions(+), 1179 deletions(-)
 delete mode 100644 include/react/engine/PulsecountEngine.h
 delete mode 100644 include/react/engine/SubtreeEngine.h
 delete mode 100644 include/react/engine/ToposortEngine.h
 delete mode 100644 include/react/logging/EventLog.h
 delete mode 100644 include/react/logging/EventRecords.h
 delete mode 100644 include/react/logging/Logging.h

diff --git a/include/react/Group.h b/include/react/Group.h
index d68526df..dd62b012 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -65,9 +65,9 @@ class TransactionStatus
 
 public:
     // Default ctor
-    inline TransactionStatus() :
+    TransactionStatus() :
         statePtr_( StateT::Create() )
-    {}
+        { }
 
     // Move ctor
     TransactionStatus(TransactionStatus&& other) :
@@ -91,7 +91,7 @@ class TransactionStatus
     TransactionStatus(const TransactionStatus&) = delete;
     TransactionStatus& operator=(const TransactionStatus&) = delete;
 
-    inline void Wait()
+    void Wait()
     {
         assert(statePtr_.Get() != nullptr);
         statePtr_->Wait();
diff --git a/include/react/common/Containers.h b/include/react/common/Containers.h
index a03257db..79980acf 100644
--- a/include/react/common/Containers.h
+++ b/include/react/common/Containers.h
@@ -14,59 +14,41 @@
 #include <algorithm>
 #include <array>
 #include <iterator>
+#include <memory>
 #include <type_traits>
-#include <vector>
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EnumFlags
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class EnumFlags
-{
-public:
-    using FlagsT = typename std::underlying_type<T>::type;
-
-    template <T x>
-    void Set() { flags_ |= 1 << x; }
-
-    template <T x>
-    void Clear() { flags_ &= ~(1 << x); }
-
-    template <T x>
-    bool Test() const { return (flags_ & (1 << x)) != 0; }
-
-private:
-    FlagsT  flags_ = 0;
-};
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IndexMap
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class IndexMap
+class IndexedStorage
 {
     static const size_t initial_capacity = 8;
     static const size_t grow_factor = 2;
 
+    using StorageType = typename std::aligned_storage<sizeof(T), alignof(T)>::type;
+
 public:
     using ValueType = T;
 
-    IndexMap() = default;
+    IndexedStorage() = default;
 
-    IndexMap(const IndexMap&) = default;
-    IndexMap& operator=(const IndexMap&) = default;
+    IndexedStorage(IndexedStorage&&) = default;
+    IndexedStorage& operator=(IndexedStorage&&) = default;
 
-    IndexMap(IndexMap&&) = default;
-    IndexMap& operator=(IndexMap&&) = default;
+    IndexedStorage(const IndexedStorage&) = delete;
+    IndexedStorage& operator=(const IndexedStorage&) = delete;
+
+    ~IndexedStorage()
+        { Reset(); }
 
     T& operator[](size_t index)
-        { return data_[index]; }
+        { return reinterpret_cast<T&>(data_[index]); }
 
     const T& operator[](size_t index) const
-        { return data_[index]; }
+        { return reinterpret_cast<T&>(data_[index]); }
 
     size_t Insert(T value)
     {
@@ -85,61 +67,73 @@ class IndexMap
         }
     }
 
-    void Remove(size_t index)
+    void Erase(size_t index)
     {
-        for (size_t index : freeIndices_)
-            data_[index].~T();
+        // If we erased something other than the last element, save in free index list.
+        if (index != (size_ - 1))
+        {
+            freeIndices_[freeSize_++] = index;
+        }
+
+        reinterpret_cast<T&>(data_[index]).~T();
         --size_;
-        freeIndices_.push_back(index);
     }
 
     void Clear()
     {
-        // Sort free indexes so we can remove check for them in linear time
-        std::sort(freeIndices_.begin(), freeIndices_.end());
+        // Sort free indexes so we can remove check for them in linear time.
+        std::sort(&freeIndices_[0], &freeIndices_[freeSize_]);
         
-        const size_t totalSize = size_ + freeIndices_.size();
-        size_t i = 0;
+        const size_t totalSize = size_ + freeSize_;
+        size_t index = 0;
 
-        // Skip over free indices
-        for (auto freeIndex : freeIndices_)
+        // Skip over free indices.
+        for (size_t j = 0; j < freeSize_; ++j)
         {
-            for (; i < totalSize; ++i)
+            for (; index < totalSize; ++index)
             {
-                if (i == freeIndex)
+                if (j == freeIndex_)
+                {
+                    ++index;
                     break;
+                }
                 else
-                    data_[i].~T();
+                {
+                    data_[index].~T();
+                }
             }
         }
 
         // Rest
-        for (; i < totalSize; ++i)
-            data_[i].~T();
+        for (; index < totalSize; ++index)
+            data_[index].~T();
 
         size_ = 0;
-        freeIndices_.clear();
+        freeList_ = 0;
     }
 
     void Reset()
     {
         Clear();
 
-        capacity_ = 0;
-        delete[] data_;
+        data_.reset();
+        freeIndices_.reset();
 
-        freeIndices_.shrink_to_fit();
+        capacity_ = 0;
     }
 
-    ~IndexMap()
-        { Reset(); }
-
 private:
+    T& GetDataAt(size_t index)
+        { return reinterpret_cast<T&>(data_[index]); }
+
+    T& GetDataAt(size_t index) const
+        { return reinterpret_cast<T&>(data_[index]); }
+
     bool IsAtFullCapacity() const
         { return capacity_ == size_; }
 
     bool HasFreeIndices() const
-        { return !freeIndices_.empty(); }
+        { return freeSize_ > 0; }
 
     size_t CalcNextCapacity() const
         { return capacity_ == 0? initial_capacity : capacity_ * grow_factor;  }
@@ -148,20 +142,23 @@ class IndexMap
     {
         // Allocate new storage
         size_t  newCapacity = CalcNextCapacity();
-        T*      newData = new T[newCapacity];
+        
+        std::unique_ptr<StorageType[]> newData{ new StorageType[newCapacity] };
+        std::unique_ptr<size_t[]> newFreeList{ new size_t[newCapacity] };
 
         // Move data to new storage
-        for (size_t i = 0; i < size_; ++i)
+        for (size_t i = 0; i < capacity_; ++i)
         {
-            new (&newData[i]) T(std::move(data_[i]));
-            data_[i].~T();
+            new (reinterpret_cast<T*>(&newData[i])) T{ std::move(reinterpret_cast<T&>(data_[i])) };
+            reinterpret_cast<T&>(data_[i]).~T();
         }
-            
-        delete[] data_;
+
+        // Free list is empty if we are at max capacity anyway
 
         // Use new storage
-        data_ = newData;
-        capacity_ = newCapacity;
+        data_           = std::move(newData);
+        freeIndices_    = std::move(newFreeList);
+        capacity_       = newCapacity;
     }
 
     size_t InsertAtBack(T&& value)
@@ -172,153 +169,19 @@ class IndexMap
 
     size_t InsertAtFreeIndex(T&& value)
     {
-        size_t nextFreeIndex = freeIndices_.back();
-        freeIndices_.pop_back();
-
+        size_t nextFreeIndex = freeIndices_[--freeSize_];
         new (&data_[nextFreeIndex]) T(std::move(value));
         ++size_;
 
         return nextFreeIndex;
     }
 
-    T*      data_       = nullptr;
+    std::unique_ptr<StorageType[]>  data_;
+    std::unique_ptr<size_t[]>       freeIndices_;
+
     size_t  size_       = 0;
+    size_t  freeSize_   = 0;
     size_t  capacity_   = 0;
-
-    std::vector<size_t> freeIndices_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeVector
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode>
-class NodeVector
-{
-private:
-    typedef std::vector<TNode*>    DataT;
-
-public:
-    void Add(TNode& node)
-    {
-        data_.push_back(&node);
-    }
-
-    void Remove(const TNode& node)
-    {
-        data_.erase(std::find(data_.begin(), data_.end(), &node));
-    }
-
-    typedef typename DataT::iterator        iterator;
-    typedef typename DataT::const_iterator  const_iterator;
-
-    iterator    begin() { return data_.begin(); }
-    iterator    end()   { return data_.end(); }
-
-    const_iterator begin() const    { return data_.begin(); }
-    const_iterator end() const      { return data_.end(); }
-
-private:
-    DataT    data_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeBuffer
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct SplitTag {};
-
-template <typename T, size_t N>
-class NodeBuffer
-{
-public:
-    using DataT = std::array<T*,N>;
-    using iterator = typename DataT::iterator;
-    using const_iterator = typename DataT::const_iterator;
-
-    static const size_t split_size = N / 2;
-
-    NodeBuffer() :
-        size_( 0 ),
-        front_( nodes_.begin() ),
-        back_( nodes_.begin() )
-    {}
-
-    NodeBuffer(T* node) :
-        size_( 1 ),
-        front_( nodes_.begin() ),
-        back_( nodes_.begin() + 1 )
-    {
-        nodes_[0] = node;
-    }
-
-    template <typename TInput>
-    NodeBuffer(TInput srcBegin, TInput srcEnd) :
-        size_( std::distance(srcBegin, srcEnd) ), // parentheses to allow narrowing conversion
-        front_( nodes_.begin() ),
-        back_( size_ != N ? nodes_.begin() + size_ : nodes_.begin() )
-    {
-        std::copy(srcBegin, srcEnd, front_);
-    }
-
-    // Other must be full
-    NodeBuffer(NodeBuffer& other, SplitTag) :
-        size_( split_size ),
-        front_( nodes_.begin() ),
-        back_( nodes_.begin() )
-    {
-        for (auto i=0; i<split_size; i++)
-            *(back_++) = other.PopFront();
-    }
-
-    void PushFront(T* e)
-    {
-        size_++;
-        decrement(front_);
-        *front_ = e;
-    }
-
-    void PushBack(T* e)
-    {
-        size_++;
-        *back_ = e;
-        increment(back_);
-    }
-
-    T* PopFront()
-    {
-        size_--;
-        auto t = *front_;
-        increment(front_);
-        return t;
-    }
-
-    T* PopBack()
-    {
-        size_--;
-        decrement(back_);
-        return *back_;
-    }
-
-    bool IsFull() const     { return size_ == N; }
-    bool IsEmpty() const    { return size_ == 0; }
-
-private:
-    inline void increment(iterator& it)
-    {
-        if (++it == nodes_.end())
-            it = nodes_.begin();
-    }
-
-    inline void decrement(iterator& it)
-    {
-        if (it == nodes_.begin())
-            it = nodes_.end();
-        --it;
-    }
-
-    DataT       nodes_;
-    size_t      size_;
-    iterator    front_;
-    iterator    back_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
index d1cead73..2fc0d048 100644
--- a/include/react/detail/graph/PropagationST.h
+++ b/include/react/detail/graph/PropagationST.h
@@ -215,8 +215,9 @@ class ReactiveGraph
 private:
     TransactionQueue    transactionQueue_{ *this };
 
+    IndexedStorage<NodeData>    nodeData_;
+
     TopoQueue           scheduledNodes_;
-    IndexMap<NodeData>  nodeData_;
     std::vector<NodeId> changedInputs_;
     LinkOutputMap       scheduledLinkOutputs_;
 
@@ -232,7 +233,7 @@ NodeId ReactiveGraph::RegisterNode(IReactiveNode* nodePtr, NodeCategory category
 
 void ReactiveGraph::UnregisterNode(NodeId nodeId)
 {
-    nodeData_.Remove(nodeId);
+    nodeData_.Erase(nodeId);
 }
 
 void ReactiveGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
diff --git a/include/react/engine/PulsecountEngine.h b/include/react/engine/PulsecountEngine.h
deleted file mode 100644
index 78999c6f..00000000
--- a/include/react/engine/PulsecountEngine.h
+++ /dev/null
@@ -1,151 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_ENGINE_PULSECOUNTENGINE_H_INCLUDED
-#define REACT_DETAIL_ENGINE_PULSECOUNTENGINE_H_INCLUDED
-
-#pragma once
-
-#if 0
-
-#include "react/detail/Defs.h"
-
-#include <atomic>
-#include <type_traits>
-#include <vector>
-
-#include "tbb/task_group.h"
-#include "tbb/spin_rw_mutex.h"
-#include "tbb/task.h"
-
-#include "react/common/Containers.h"
-#include "react/common/Types.h"
-#include "react/detail/EngineBase.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-namespace pulsecount {
-
-using std::atomic;
-using std::vector;
-
-using tbb::task;
-using tbb::empty_task;
-using tbb::spin_rw_mutex;
-using tbb::task_list;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Turn
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class Turn : public TurnBase
-{
-public:
-    Turn(TurnIdT id, TransactionFlagsT flags);
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Node
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum class ENodeMark
-{
-    unmarked,
-    visited,
-    should_update
-};
-
-enum class ENodeState
-{
-    unchanged,
-    changed,
-    dyn_defer,
-    dyn_repeat
-};
-
-class Node : public IReactiveNode
-{
-public:
-    using ShiftMutexT = spin_rw_mutex;
-
-    inline void IncCounter() { counter_.fetch_add(1, std::memory_order_relaxed); }
-    inline bool DecCounter() { return counter_.fetch_sub(1, std::memory_order_relaxed) > 1; }
-    inline void SetCounter(int c) { counter_.store(c, std::memory_order_relaxed); }
-
-    inline ENodeMark Mark() const
-    {
-        return mark_.load(std::memory_order_relaxed);
-    }
-
-    inline void SetMark(ENodeMark mark)
-    {
-        mark_.store(mark, std::memory_order_relaxed);
-    }
-
-    inline bool ExchangeMark(ENodeMark mark)
-    {
-        return mark_.exchange(mark, std::memory_order_relaxed) != mark;
-    }
-
-    ShiftMutexT         ShiftMutex;
-    NodeVector<Node>    Successors;
-    
-    ENodeState          State       = ENodeState::unchanged;
-
-private:
-    atomic<int>         counter_    { 0 };
-    atomic<ENodeMark>   mark_       { ENodeMark::unmarked };
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EngineBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class EngineBase : public IReactiveEngine<Node,Turn>
-{
-public:
-    using NodeShiftMutexT = Node::ShiftMutexT;
-    using NodeVectT = vector<Node*>;
-
-    void OnNodeAttach(Node& node, Node& parent);
-    void OnNodeDetach(Node& node, Node& parent);
-
-    void OnInputChange(Node& node, Turn& turn);
-    void Propagate(Turn& turn);
-
-    void OnNodePulse(Node& node, Turn& turn);
-    void OnNodeIdlePulse(Node& node, Turn& turn);
-
-    void OnDynamicNodeAttach(Node& node, Node& parent, Turn& turn);
-    void OnDynamicNodeDetach(Node& node, Node& parent, Turn& turn);
-
-private:
-    NodeVectT       changedInputs_;
-    empty_task&     rootTask_       = *new(task::allocate_root()) empty_task;
-    task_list       spawnList_;
-};
-
-} // ~namespace pulsecount
-/****************************************/ REACT_IMPL_END /***************************************/
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-template <REACT_IMPL::EPropagationMode>
-class PulsecountEngine;
-
-template <>
-class PulsecountEngine<REACT_IMPL::parallel_propagation> :
-    public REACT_IMPL::pulsecount::EngineBase
-{};
-
-/******************************************/ REACT_END /******************************************/
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <>
-struct NodeUpdateTimerEnabled<PulsecountEngine<parallel_propagation>> : std::true_type {};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_ENGINE_PULSECOUNTENGINE_H_INCLUDED
-
-#endif
\ No newline at end of file
diff --git a/include/react/engine/SubtreeEngine.h b/include/react/engine/SubtreeEngine.h
deleted file mode 100644
index 447c1184..00000000
--- a/include/react/engine/SubtreeEngine.h
+++ /dev/null
@@ -1,198 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#if 0
-
-#ifndef REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
-#define REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <atomic>
-#include <type_traits>
-#include <vector>
-
-#include "tbb/spin_rw_mutex.h"
-#include "tbb/task.h"
-
-#include "react/common/Containers.h"
-#include "react/common/TopoQueue.h"
-#include "react/common/Types.h"
-#include "react/detail/EngineBase.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-namespace subtree {
-
-using std::atomic;
-using std::vector;
-
-using tbb::task;
-using tbb::empty_task;
-using tbb::task_list;
-using tbb::spin_rw_mutex;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Turn
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class Turn : public TurnBase
-{
-public:
-    Turn(TurnIdT id, TransactionFlagsT flags);
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Node
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class Node : public IReactiveNode
-{
-public:
-    using ShiftMutexT = spin_rw_mutex;
-
-    inline bool IsQueued() const    { return flags_.Test<flag_queued>(); }
-    inline void SetQueuedFlag()     { flags_.Set<flag_queued>(); }
-    inline void ClearQueuedFlag()   { flags_.Clear<flag_queued>(); }
-
-    inline bool IsMarked() const    { return flags_.Test<flag_marked>(); }
-    inline void SetMarkedFlag()     { flags_.Set<flag_marked>(); }
-    inline void ClearMarkedFlag()   { flags_.Clear<flag_marked>(); }
-
-    inline bool IsChanged() const   { return flags_.Test<flag_changed>(); }
-    inline void SetChangedFlag()    { flags_.Set<flag_changed>(); }
-    inline void ClearChangedFlag()  { flags_.Clear<flag_changed>(); }
-
-    inline bool IsDeferred() const   { return flags_.Test<flag_deferred>(); }
-    inline void SetDeferredFlag()    { flags_.Set<flag_deferred>(); }
-    inline void ClearDeferredFlag()  { flags_.Clear<flag_deferred>(); }
-
-    inline bool IsRepeated() const   { return flags_.Test<flag_repeated>(); }
-    inline void SetRepeatedFlag()    { flags_.Set<flag_repeated>(); }
-    inline void ClearRepeatedFlag()  { flags_.Clear<flag_repeated>(); }
-
-    inline bool IsInitial() const   { return flags_.Test<flag_initial>(); }
-    inline void SetInitialFlag()    { flags_.Set<flag_initial>(); }
-    inline void ClearInitialFlag()  { flags_.Clear<flag_initial>(); }
-
-    inline bool IsRoot() const      { return flags_.Test<flag_root>(); }
-    inline void SetRootFlag()       { flags_.Set<flag_root>(); }
-    inline void ClearRootFlag()     { flags_.Clear<flag_root>(); }
-
-    inline bool ShouldUpdate() const { return shouldUpdate_.load(std::memory_order_relaxed); }
-    inline void SetShouldUpdate(bool b) { shouldUpdate_.store(b, std::memory_order_relaxed); }
-
-    inline void SetReadyCount(int c)
-    {
-        readyCount_.store(c, std::memory_order_relaxed);
-    }
-
-    inline bool IncReadyCount()
-    {
-        auto t = readyCount_.fetch_add(1, std::memory_order_relaxed);
-        return t < (WaitCount - 1);
-    }
-
-    inline bool DecReadyCount()
-    {
-        return readyCount_.fetch_sub(1, std::memory_order_relaxed) > 1;
-    }
-
-    NodeVector<Node>    Successors;
-    ShiftMutexT         ShiftMutex;
-    uint16_t            Level       = 0;
-    uint16_t            NewLevel    = 0;
-    uint16_t            WaitCount   = 0;
-
-private:
-    enum EFlags : uint16_t
-    {
-        flag_queued = 0,
-        flag_marked,
-        flag_changed,
-        flag_deferred,
-        flag_repeated,
-        flag_initial,
-        flag_root
-    };
-
-    EnumFlags<EFlags>   flags_;
-    atomic<uint16_t>    readyCount_     { 0 };
-    atomic<bool>        shouldUpdate_   { false };
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Functors
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct GetLevelFunctor
-{
-    int operator()(const T* x) const { return x->Level; }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EngineBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class EngineBase : public IReactiveEngine<Node,Turn>
-{
-public:
-    using TopoQueueT = TopoQueue<Node*, GetLevelFunctor<Node>>;
-    using NodeShiftMutexT = Node::ShiftMutexT;
-
-    void OnNodeAttach(Node& node, Node& parent);
-    void OnNodeDetach(Node& node, Node& parent);
-
-    void OnInputChange(Node& node, Turn& turn);
-    void Propagate(Turn& turn);
-
-    void OnNodePulse(Node& node, Turn& turn);
-    void OnNodeIdlePulse(Node& node, Turn& turn);
-
-    void OnDynamicNodeAttach(Node& node, Node& parent, Turn& turn);
-    void OnDynamicNodeDetach(Node& node, Node& parent, Turn& turn);
-
-private:
-    void applyAsyncDynamicAttach(Node& node, Node& parent, Turn& turn);
-    void applyAsyncDynamicDetach(Node& node, Node& parent, Turn& turn);
-
-    void invalidateSuccessors(Node& node);
-    void processChildren(Node& node, Turn& turn);
-
-    void markSubtree(Node& root);
-
-    TopoQueueT      scheduledNodes_;
-    vector<Node*>   subtreeRoots_;
-
-    empty_task&     rootTask_   = *new(task::allocate_root()) empty_task;
-    task_list       spawnList_;
-
-    bool            isInPhase2_ = false;
-}; 
-
-} // ~namespace subtree
-/****************************************/ REACT_IMPL_END /***************************************/
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-template <REACT_IMPL::EPropagationMode>
-class SubtreeEngine;
-
-template <>
-class SubtreeEngine<REACT_IMPL::parallel_propagation> :
-    public REACT_IMPL::subtree::EngineBase
-{};
-
-/******************************************/ REACT_END /******************************************/
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <>
-struct NodeUpdateTimerEnabled<SubtreeEngine<parallel_propagation>> : std::true_type {};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_ENGINE_SUBTREEENGINE_H_INCLUDED
-
-#endif
\ No newline at end of file
diff --git a/include/react/engine/ToposortEngine.h b/include/react/engine/ToposortEngine.h
deleted file mode 100644
index 2575bbd9..00000000
--- a/include/react/engine/ToposortEngine.h
+++ /dev/null
@@ -1,214 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#if 0
-
-#ifndef REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
-#define REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <atomic>
-#include <utility>
-#include <type_traits>
-#include <vector>
-
-#include "tbb/concurrent_vector.h"
-#include "tbb/spin_mutex.h"
-
-#include "react/common/Containers.h"
-#include "react/common/TopoQueue.h"
-#include "react/common/Types.h"
-#include "react/detail/EngineBase.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-namespace toposort {
-
-using std::atomic;
-using std::vector;
-using tbb::concurrent_vector;
-using tbb::spin_mutex;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Parameters
-///////////////////////////////////////////////////////////////////////////////////////////////////
-static const uint min_weight = 1;
-static const uint grain_size = 100;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SeqNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class SeqNode : public IReactiveNode
-{
-public:
-    int     Level       { 0 };
-    int     NewLevel    { 0 };
-    bool    Queued      { false };
-
-    NodeVector<SeqNode>     Successors;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ParNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class ParNode : public IReactiveNode
-{
-public:
-    using InvalidateMutexT = spin_mutex;
-
-    int             Level       { 0 };
-    int             NewLevel    { 0 };
-    atomic<bool>    Collected   { false };
-
-    NodeVector<ParNode> Successors;
-    InvalidateMutexT    InvalidateMutex;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ShiftRequestData
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct DynRequestData
-{
-    bool        ShouldAttach;
-    ParNode*    Node;
-    ParNode*    Parent;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ExclusiveSeqTurn
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class SeqTurn : public TurnBase
-{
-public:
-    SeqTurn(TurnIdT id, TransactionFlagsT flags);
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ExclusiveParTurn
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class ParTurn : public TurnBase
-{
-public:
-    ParTurn(TurnIdT id, TransactionFlagsT flags);
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Functors
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct GetLevelFunctor
-{
-    int operator()(const T* x) const { return x->Level; }
-};
-
-template <typename T>
-struct GetWeightFunctor
-{
-    uint operator()(T* x) const { return x->IsHeavyweight() ? grain_size : 1; }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EngineBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TNode, typename TTurn>
-class EngineBase : public IReactiveEngine<TNode,TTurn>
-{
-public:
-    void OnNodeAttach(TNode& node, TNode& parent);
-    void OnNodeDetach(TNode& node, TNode& parent);
-
-    void OnInputChange(TNode& node, TTurn& turn);
-    void OnNodePulse(TNode& node, TTurn& turn);
-
-protected:
-    virtual void processChildren(TNode& node, TTurn& turn) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SeqEngineBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class SeqEngineBase : public EngineBase<SeqNode,SeqTurn>
-{
-public:
-    using TopoQueueT = TopoQueue<SeqNode*, GetLevelFunctor<SeqNode>>;
-
-    void Propagate(SeqTurn& turn);
-
-    void OnDynamicNodeAttach(SeqNode& node, SeqNode& parent, SeqTurn& turn);
-    void OnDynamicNodeDetach(SeqNode& node, SeqNode& parent, SeqTurn& turn);
-
-private:
-    void invalidateSuccessors(SeqNode& node);
-
-    virtual void processChildren(SeqNode& node, SeqTurn& turn) override;
-
-    TopoQueueT    scheduledNodes_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ParEngineBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class ParEngineBase : public EngineBase<ParNode,ParTurn>
-{
-public:
-    using DynRequestVectT = concurrent_vector<DynRequestData>;
-    using TopoQueueT = ConcurrentTopoQueue
-    <
-        ParNode*,
-        grain_size,
-        GetLevelFunctor<ParNode>,
-        GetWeightFunctor<ParNode>
-    >;
-
-    void Propagate(ParTurn& turn);
-
-    void OnDynamicNodeAttach(ParNode& node, ParNode& parent, ParTurn& turn);
-    void OnDynamicNodeDetach(ParNode& node, ParNode& parent, ParTurn& turn);
-
-private:
-    void applyDynamicAttach(ParNode& node, ParNode& parent, ParTurn& turn);
-    void applyDynamicDetach(ParNode& node, ParNode& parent, ParTurn& turn);
-
-    void invalidateSuccessors(ParNode& node);
-
-    virtual void processChildren(ParNode& node, ParTurn& turn) override;
-
-    TopoQueueT          topoQueue_;
-    DynRequestVectT     dynRequests_;
-};
-
-} // ~namespace toposort
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-template <REACT_IMPL::EPropagationMode>
-class ToposortEngine;
-
-template <> class ToposortEngine<REACT_IMPL::sequential_propagation> :
-    public REACT_IMPL::toposort::SeqEngineBase
-{};
-
-template <> class ToposortEngine<REACT_IMPL::parallel_propagation> :
-    public REACT_IMPL::toposort::ParEngineBase
-{};
-
-/******************************************/ REACT_END /******************************************/
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <>
-struct NodeUpdateTimerEnabled<ToposortEngine<parallel_propagation>> : std::true_type {};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_ENGINE_TOPOSORTENGINE_H_INCLUDED
-
-#endif
\ No newline at end of file
diff --git a/include/react/logging/EventLog.h b/include/react/logging/EventLog.h
deleted file mode 100644
index 6b94277f..00000000
--- a/include/react/logging/EventLog.h
+++ /dev/null
@@ -1,100 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_LOGGING_EVENTLOG_H_INCLUDED
-#define REACT_DETAIL_LOGGING_EVENTLOG_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <memory>
-#include <cstdint>
-#include <functional>
-#include <iostream>
-#include <chrono>
-
-#include "tbb/concurrent_vector.h"
-
-#include "Logging.h"
-#include "react/common/Types.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventLog
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class EventLog
-{
-    using TimestampT = std::chrono::time_point<std::chrono::high_resolution_clock>;
-
-    class Entry
-    {
-    public:
-        Entry();
-        Entry(const Entry& other);
-
-        explicit Entry(IEventRecord* ptr);
-
-        Entry& operator=(Entry& rhs);
-
-        inline const char* EventId() const
-        {
-            return data_->EventId();
-        }
-
-        inline const TimestampT& Time() const
-        {
-            return time_;
-        }
-
-        inline bool operator<(const Entry& other) const
-        {
-            return time_ < other.time_;
-        }
-
-        inline void Release()
-        {
-            delete data_;
-        }
-
-        void Serialize(std::ostream& out, const TimestampT& startTime) const;
-        bool Equals(const Entry& other) const;
-
-    private:
-        TimestampT      time_;
-        IEventRecord*   data_;
-    };
-
-public:
-
-    EventLog();
-    ~EventLog();
-
-    void    Print();
-    void    Write(std::ostream& out);
-    void    Clear();
-
-    template
-    <
-        typename TEventRecord,
-        typename ... TArgs
-    >
-    void Append(TArgs ... args)
-    {
-        entries_.push_back(Entry(new TEventRecord(args ...)));
-    }
-
-private:
-    using LogEntriesT = tbb::concurrent_vector<Entry>;
-
-    LogEntriesT     entries_;
-    TimestampT      startTime_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_LOGGING_EVENTLOG_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/logging/EventRecords.h b/include/react/logging/EventRecords.h
deleted file mode 100644
index ea2359f5..00000000
--- a/include/react/logging/EventRecords.h
+++ /dev/null
@@ -1,263 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_LOGGING_EVENTRECORDS_H_INCLUDED
-#define REACT_DETAIL_LOGGING_EVENTRECORDS_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <iostream>
-#include <string>
-#include <thread>
-
-#include "Logging.h"
-#include "react/common/Types.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeCreateEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeCreateEvent : public IEventRecord
-{
-public:
-    NodeCreateEvent(ObjectId nodeId, const char* type);
-
-    virtual const char* EventId() const { return "NodeCreate"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId        nodeId_;
-    const char *    type_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeDestroyEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeDestroyEvent : public IEventRecord
-{
-public:
-    NodeDestroyEvent(ObjectId nodeId);
-
-    virtual const char* EventId() const { return "NodeDestroy"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeAttachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeAttachEvent : public IEventRecord
-{
-public:
-    NodeAttachEvent(ObjectId nodeId, ObjectId parentId);
-
-    virtual const char* EventId() const { return "NodeAttach"; }
-    
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    ObjectId    parentId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeDetachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeDetachEvent : public IEventRecord
-{
-public:
-    NodeDetachEvent(ObjectId nodeId, ObjectId parentId);
-
-    virtual const char* EventId() const { return "NodeDetach"; }
-    
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    ObjectId    parentId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// InputNodeAdmissionEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class InputNodeAdmissionEvent : public IEventRecord
-{
-public:
-    InputNodeAdmissionEvent(ObjectId nodeId, int transactionId);
-
-    virtual const char* EventId() const { return "InputNodeAdmission"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    int         transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodePulseEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodePulseEvent : public IEventRecord
-{
-public:
-    NodePulseEvent(ObjectId nodeId, int transactionId);
-
-    virtual const char* EventId() const { return "NodePulse"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    int         transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeIdlePulseEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeIdlePulseEvent : public IEventRecord
-{
-public:
-    NodeIdlePulseEvent(ObjectId nodeId, int transactionId);
-
-    virtual const char* EventId() const { return "NodeIdlePulse"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    int         transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DynamicNodeAttachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class DynamicNodeAttachEvent : public IEventRecord
-{
-public:
-    DynamicNodeAttachEvent(ObjectId nodeId, ObjectId parentId, int transactionId);
-
-    virtual const char* EventId() const { return "DynamicNodeAttach"; }
-    
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    ObjectId    parentId_;
-    int         transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DynamicNodeDetachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class DynamicNodeDetachEvent : public IEventRecord
-{
-public:
-    DynamicNodeDetachEvent(ObjectId nodeId, ObjectId parentId, int transactionId);
-
-    virtual const char* EventId() const { return "DynamicNodeDetach"; }
-    
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId    nodeId_;
-    ObjectId    parentId_;
-    int         transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeEvaluateBeginEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeEvaluateBeginEvent : public IEventRecord
-{
-public:
-    NodeEvaluateBeginEvent(ObjectId nodeId, int transactionId);
-
-    virtual const char* EventId() const { return "NodeEvaluateBegin"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId        nodeId_;
-    int             transactionId_;
-    std::thread::id threadId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeEvaluateEndEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeEvaluateEndEvent : public IEventRecord
-{
-public:
-    NodeEvaluateEndEvent(ObjectId nodeId, int transactionId);
-
-    virtual const char* EventId() const { return "NodeEvaluateEnd"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    ObjectId        nodeId_;
-    int             transactionId_;
-    std::thread::id threadId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TransactionBeginEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class TransactionBeginEvent : public IEventRecord
-{
-public:
-    TransactionBeginEvent(int transactionId);
-
-    virtual const char* EventId() const { return "TransactionBegin"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    int transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TransactionEndEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class TransactionEndEvent : public IEventRecord
-{
-public:
-    TransactionEndEvent(int transactionId);
-
-    virtual const char* EventId() const { return "TransactionEnd"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    int transactionId_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// UserBreakpointEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class UserBreakpointEvent : public IEventRecord
-{
-public:
-    UserBreakpointEvent(const char* name);
-
-    virtual const char* EventId() const { return "UserBreakpoint"; }
-
-    virtual void Serialize(std::ostream& out) const;
-
-private:
-    std::string name_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_LOGGING_EVENTRECORDS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/logging/Logging.h b/include/react/logging/Logging.h
deleted file mode 100644
index 3f0aacd2..00000000
--- a/include/react/logging/Logging.h
+++ /dev/null
@@ -1,31 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_LOGGING_LOGGING_H_INCLUDED
-#define REACT_DETAIL_LOGGING_LOGGING_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <iostream>
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IEventRecord
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IEventRecord
-{
-    virtual ~IEventRecord() {}
-
-    virtual const char* EventId() const = 0;
-    virtual void        Serialize(std::ostream& out) const = 0;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_LOGGING_LOGGING_H_INCLUDED
\ No newline at end of file
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index ead65969..6b961f03 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -168,9 +168,6 @@
     <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h" />
     <ClInclude Include="..\..\include\react\detail\IReactiveGraph.h" />
     <ClInclude Include="..\..\include\react\Group.h" />
-    <ClInclude Include="..\..\include\react\engine\PulsecountEngine.h" />
-    <ClInclude Include="..\..\include\react\engine\SubtreeEngine.h" />
-    <ClInclude Include="..\..\include\react\engine\ToposortEngine.h" />
     <ClInclude Include="..\..\include\react\common\Concurrency.h" />
     <ClInclude Include="..\..\include\react\common\Containers.h" />
     <ClInclude Include="..\..\include\react\common\SourceIdSet.h" />
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index 76abe5da..c78bde77 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -19,9 +19,6 @@
     <Filter Include="Header Files\detail\graph">
       <UniqueIdentifier>{c7adc39d-d19e-4fe2-b945-332515717bc8}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\engine">
-      <UniqueIdentifier>{6883dd62-b27e-4b11-9cc8-cbac096f4723}</UniqueIdentifier>
-    </Filter>
     <Filter Include="Header Files\common">
       <UniqueIdentifier>{11a75126-8bfd-4693-be4b-4e06ab73450c}</UniqueIdentifier>
     </Filter>
@@ -48,9 +45,6 @@
     <ClInclude Include="..\..\include\react\common\Concurrency.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\engine\SubtreeEngine.h">
-      <Filter>Header Files\engine</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\Defs.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
@@ -72,15 +66,9 @@
     <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h">
       <Filter>Header Files\detail\graph</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\engine\ToposortEngine.h">
-      <Filter>Header Files\engine</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\common\Timing.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\engine\PulsecountEngine.h">
-      <Filter>Header Files\engine</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\common\RefCounting.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>

From d0e5375b9e70cace84c4b2a9a97e8666a149cb69 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Tue, 24 Oct 2017 02:36:31 +0200
Subject: [PATCH 52/75] Progress dump.

---
 benchmarks/src/BenchmarkBase.h                |   2 +-
 benchmarks/src/BenchmarkFanout.h              |   2 +-
 benchmarks/src/BenchmarkGrid.h                |   2 +-
 benchmarks/src/BenchmarkLifeSim.h             |   2 +-
 benchmarks/src/BenchmarkRandom.h              |   2 +-
 benchmarks/src/BenchmarkSequence.h            |   2 +-
 benchmarks/src/Main.cpp                       |  52 +-
 examples/src/BasicAlgorithms.cpp              |   2 +-
 examples/src/BasicComposition.cpp             |   2 +-
 examples/src/BasicEvents.cpp                  |   2 +-
 examples/src/BasicObservers.cpp               |   2 +-
 examples/src/BasicSignals.cpp                 |   2 +-
 examples/src/BasicSynchronization.cpp         |   2 +-
 examples/src/Main.cpp                         |   7 +-
 include/react/API.h                           |  11 +-
 include/react/Algorithm.h                     |  87 +-
 include/react/Event.h                         | 172 +--
 include/react/Group.h                         |  75 +-
 include/react/Observer.h                      |  79 +-
 include/react/Signal.h                        | 126 +--
 include/react/common/Concurrency.h            | 324 ------
 include/react/common/RefCounting.h            |   4 +-
 include/react/common/SourceIdSet.h            |   4 +-
 include/react/common/Timing.h                 |   4 +-
 include/react/common/TopoQueue.h              |   4 +-
 include/react/common/Types.h                  |   4 +-
 include/react/common/Util.h                   | 249 -----
 include/react/common/expected.h               | 218 ++++
 include/react/common/optional.h               |  70 ++
 include/react/common/owned_ptr.h              |  18 +
 include/react/common/ptrcache.h               |  65 ++
 .../react/common/{Containers.h => slotmap.h}  |  40 +-
 include/react/common/syncpoint.h              | 195 ++++
 include/react/common/utility.h                |  58 ++
 include/react/detail/Defs.h                   |   9 +-
 include/react/detail/ReactiveInput.h          | 983 ------------------
 .../AlgorithmNodes.h => algorithm_nodes.h}    | 162 +--
 .../{graph/EventNodes.h => event_nodes.h}     | 280 ++---
 include/react/detail/graph/PropagationMT.h    |   0
 include/react/detail/graph/PropagationST.h    | 500 ---------
 include/react/detail/graph_impl.h             | 224 ++++
 .../{IReactiveGraph.h => graph_interface.h}   |  42 +-
 .../detail/{graph/GraphBase.h => node_base.h} |  40 +-
 .../ObserverNodes.h => observer_nodes.h}      |  60 +-
 .../{graph/SignalNodes.h => signal_nodes.h}   | 159 ++-
 project/msvc/CppReact.sln                     |  33 +-
 project/msvc/CppReact.vcxproj                 |  56 +-
 project/msvc/CppReact.vcxproj.filters         |  91 +-
 project/msvc/CppReactBenchmark.vcxproj        |  10 +-
 project/msvc/CppReactExample.vcxproj          |  10 +-
 project/msvc/CppReactTest.vcxproj             |  44 +-
 project/msvc/CppReactTest.vcxproj.filters     |  45 +-
 project/msvc/Example_BasicAlgorithms.vcxproj  |  10 +-
 project/msvc/Example_BasicComposition.vcxproj |  10 +-
 project/msvc/Example_BasicEvents.vcxproj      |  10 +-
 project/msvc/Example_BasicObservers.vcxproj   |  10 +-
 project/msvc/Example_BasicSignals.vcxproj     |  10 +-
 .../msvc/Example_BasicSynchronization.vcxproj |  10 +-
 src/detail/graph_impl.cpp                     | 248 +++++
 src/engine/PulsecountEngine.cpp               |   6 +-
 src/engine/SubtreeEngine.cpp                  |  10 +-
 src/engine/ToposortEngine.cpp                 |  14 +-
 src/logging/EventLog.cpp                      |  84 --
 src/logging/EventRecords.cpp                  | 210 ----
 tests/src/EventStreamTest.cpp                 |  29 -
 tests/src/EventStreamTest.h                   |   2 +-
 tests/src/EventStreamTestQ.cpp                |   2 +-
 tests/src/MoveTest.cpp                        |  11 +-
 tests/src/MoveTest.h                          |   2 +-
 tests/src/ObserverTest.cpp                    |  19 +-
 tests/src/ObserverTest.h                      |   2 +-
 tests/src/ObserverTestQ.cpp                   |   2 +-
 tests/src/OperationsTest.cpp                  |  19 +-
 tests/src/OperationsTest.h                    |   2 +-
 tests/src/OperationsTestQ.cpp                 |   2 +-
 tests/src/ParallelizationTest.cpp             |  19 +-
 tests/src/ParallelizationTest.h               |   2 +-
 tests/src/SignalTest.cpp                      |  20 +-
 tests/src/SignalTest.h                        |   2 +-
 tests/src/SignalTestQ.cpp                     |   2 +-
 tests/src/TestUtil.h                          |   2 +-
 tests/src/TransactionTest.cpp                 |  19 +-
 tests/src/TransactionTest.h                   |   2 +-
 tests/src/common_tests.cpp                    | 132 +++
 tests/src/event_tests.cpp                     | 219 ++++
 85 files changed, 2205 insertions(+), 3576 deletions(-)
 delete mode 100644 include/react/common/Concurrency.h
 delete mode 100644 include/react/common/Util.h
 create mode 100644 include/react/common/expected.h
 create mode 100644 include/react/common/optional.h
 create mode 100644 include/react/common/owned_ptr.h
 create mode 100644 include/react/common/ptrcache.h
 rename include/react/common/{Containers.h => slotmap.h} (82%)
 create mode 100644 include/react/common/syncpoint.h
 create mode 100644 include/react/common/utility.h
 delete mode 100644 include/react/detail/ReactiveInput.h
 rename include/react/detail/{graph/AlgorithmNodes.h => algorithm_nodes.h} (68%)
 rename include/react/detail/{graph/EventNodes.h => event_nodes.h} (66%)
 delete mode 100644 include/react/detail/graph/PropagationMT.h
 delete mode 100644 include/react/detail/graph/PropagationST.h
 create mode 100644 include/react/detail/graph_impl.h
 rename include/react/detail/{IReactiveGraph.h => graph_interface.h} (63%)
 rename include/react/detail/{graph/GraphBase.h => node_base.h} (65%)
 rename include/react/detail/{graph/ObserverNodes.h => observer_nodes.h} (69%)
 rename include/react/detail/{graph/SignalNodes.h => signal_nodes.h} (74%)
 create mode 100644 src/detail/graph_impl.cpp
 delete mode 100644 src/logging/EventLog.cpp
 delete mode 100644 src/logging/EventRecords.cpp
 delete mode 100644 tests/src/EventStreamTest.cpp
 create mode 100644 tests/src/common_tests.cpp
 create mode 100644 tests/src/event_tests.cpp

diff --git a/benchmarks/src/BenchmarkBase.h b/benchmarks/src/BenchmarkBase.h
index 7df36bbe..d27d64b1 100644
--- a/benchmarks/src/BenchmarkBase.h
+++ b/benchmarks/src/BenchmarkBase.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkFanout.h b/benchmarks/src/BenchmarkFanout.h
index 672b5f7c..a4855d0f 100644
--- a/benchmarks/src/BenchmarkFanout.h
+++ b/benchmarks/src/BenchmarkFanout.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkGrid.h b/benchmarks/src/BenchmarkGrid.h
index d7ed0bb8..8f17d6f2 100644
--- a/benchmarks/src/BenchmarkGrid.h
+++ b/benchmarks/src/BenchmarkGrid.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkLifeSim.h b/benchmarks/src/BenchmarkLifeSim.h
index 6521f2d4..2511882d 100644
--- a/benchmarks/src/BenchmarkLifeSim.h
+++ b/benchmarks/src/BenchmarkLifeSim.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkRandom.h b/benchmarks/src/BenchmarkRandom.h
index e3ffe9ef..cec422da 100644
--- a/benchmarks/src/BenchmarkRandom.h
+++ b/benchmarks/src/BenchmarkRandom.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/BenchmarkSequence.h b/benchmarks/src/BenchmarkSequence.h
index bf87bc41..705e8f58 100644
--- a/benchmarks/src/BenchmarkSequence.h
+++ b/benchmarks/src/BenchmarkSequence.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index 2af96fdd..bc42b726 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -1,17 +1,17 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
 //#define REACT_ENABLE_LOGGING
-
-#include "tbb/tick_count.h"
-#include "tbb/tbbmalloc_proxy.h"
+#if 0
+//#include "tbb/tick_count.h"
+//#include "tbb/tbbmalloc_proxy.h"
 
 //#include "ittnotify.h"
 
-#include "BenchmarkGrid.h"
+/*#include "BenchmarkGrid.h"
 #include "BenchmarkRandom.h"
 #include "BenchmarkFanout.h"
 #include "BenchmarkSequence.h"
@@ -20,12 +20,12 @@
 #include "react/Group.h"
 #include "react/Signal.h"
 #include "react/Algorithm.h"
-#include "react/common/Util.h"
+#include "react/common/Util.h"*/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
+//using namespace react;
 
 /*void runBenchmarkGrid(std::ostream& out)
 {
@@ -198,7 +198,7 @@ void debugBenchmarks()
 
 void profileBenchmark()
 {
-    RUN_BENCHMARK(std::cout, 3, Benchmark_Grid, BenchmarkParams_Grid(100, 10000));
+    //RUN_BENCHMARK(std::cout, 3, Benchmark_Grid, BenchmarkParams_Grid(100, 10000));
 
     //RUN_BENCHMARK(std::cout, 1, Benchmark_Grid, BenchmarkParams_Grid(30, 10000),
         //SourceSetDomain);
@@ -217,5 +217,39 @@ int main()
 {
     //runBenchmarks();
     //debugBenchmarks();    
-    profileBenchmark();
+    //profileBenchmark();
+
+
+}
+
+#endif
+
+#include "react/common/expected.h"
+#include "react/signal.h"
+#include "react/event.h"
+#include "react/algorithm.h"
+#include <iostream>
+
+#define unwind_on_error(x) if (!x) return UnwindExpected(std::move(x));
+
+using namespace react;
+
+
+int main()
+{
+    Group g;
+
+    VarSignal<int> t1(g);
+    VarSignal<int> t2(g);
+
+    EventSource<int> e1(g);
+    EventSource<int> e2(g);
+
+    auto h1 = Hold(1, e1);
+    auto h2 = Hold(2, e2);
+
+    auto m1 = Monitor(t1);
+    auto it1 = Iterate<int>(10, [] (EventRange<int> evnts, int b) { return b; }, e1);
+
+    return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index c2c5d123..93235700 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicComposition.cpp b/examples/src/BasicComposition.cpp
index d5354bae..e2fbf3b1 100644
--- a/examples/src/BasicComposition.cpp
+++ b/examples/src/BasicComposition.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index da3fa4f2..53e97984 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index fede6fd0..8eb03b81 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index a8b6a60a..749116c8 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index 8eacfa6e..701b5001 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
index 5720dcf1..3d3bb8e4 100644
--- a/examples/src/Main.cpp
+++ b/examples/src/Main.cpp
@@ -15,6 +15,8 @@
 #include "react/Algorithm.h"
 #include "react/Observer.h"
 
+#include "react/common/expected.h"
+
 using namespace react;
 
 template <typename T>
@@ -38,9 +40,6 @@ class GridGraphGenerator
 
     void Generate(const Group& group)
     {
-        assert(inputSignals.size() >= 1);
-        assert(widths.size() >= 1);
-
         SignalVectType buf1 = std::move(inputSignals);
         SignalVectType buf2;
 
@@ -366,6 +365,8 @@ int main()
 
     std::this_thread::sleep_for(std::chrono::seconds(5));
 
+    Expected<int> x;
+
     return 0;
 }
 
diff --git a/include/react/API.h b/include/react/API.h
index da892da8..3e20d5bb 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,8 +9,8 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
-#include "react/common/Util.h"
+#include "react/detail/defs.h"
+#include "react/common/utility.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
@@ -26,8 +26,9 @@ enum class WeightHint
 
 enum class TransactionFlags
 {
-    none          = 0,
-    allow_merging = 1 << 1
+    none            = 0,
+    allow_merging   = 1 << 1,
+    sync_linked     = 1 << 2
 };
 
 REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index babc4c8b..e149b491 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -9,28 +9,32 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <memory>
 #include <type_traits>
 #include <utility>
 
 #include "react/API.h"
-#include "react/detail/graph/AlgorithmNodes.h"
+#include "react/detail/algorithm_nodes.h"
 
-#include "Event.h"
-#include "Signal.h"
+#include "react/event.h"
+#include "react/signal.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Hold - Hold the most recent event in a signal
+/// Hold the most recent event in a signal
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, typename E>
 auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
 {
     using REACT_IMPL::HoldNode;
-    return Signal<E>::CreateWithNode<HoldNode<E>>(group, std::forward<T>(initialValue), SameGroupOrLink(group, evnt));
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<Signal<E>, HoldNode<E>>(
+        group, std::forward<T>(initialValue), SameGroupOrLink(group, evnt));
 }
 
 template <typename T, typename E>
@@ -38,13 +42,17 @@ auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
     { return Hold(evnt.GetGroup(), std::forward<T>(initialValue), evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Monitor - Emits value changes of target signal
+/// Emits value changes of target signal.
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
 auto Monitor(const Group& group, const Signal<S>& signal) -> Event<S>
 {
     using REACT_IMPL::MonitorNode;
-    return Event<S>::CreateWithNode<MonitorNode<S>>(group, SameGroupOrLink(group, signal));
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<Event<S>, MonitorNode<S>>(
+        group, SameGroupOrLink(group, signal));
 }
 
 template <typename S>
@@ -58,22 +66,38 @@ template <typename S, typename T, typename F, typename E>
 auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::IterateNode;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    using FuncType = typename std::decay<F>::type;
+
+    return CreateWrappedNode<Signal<S>, IterateNode<S, FuncType, E>>(
+        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
+}
+
+template <typename S, typename T, typename F, typename E>
+auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+{
     using REACT_IMPL::IterateByRefNode;
     using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
 
     using FuncType = typename std::decay<F>::type;
-    using IterNodeType = typename std::conditional<
-        IsCallableWith<F,S,EventRange<E>,S>::value,
-        IterateNode<S, FuncType, E>,
-        IterateByRefNode<S, FuncType, E>>::type;
 
-    return Signal<S>::CreateWithNode<IterNodeType>(group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
+    return CreateWrappedNode<Signal<S>, IterateByRefNode<S, FuncType, E>>(
+        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename T, typename F, typename E>
 auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
     { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt); }
 
+template <typename S, typename T, typename F, typename E>
+auto IterateByRef(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+    { return IterateByRef<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt); }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -81,16 +105,27 @@ template <typename S, typename T, typename F, typename E, typename ... Us>
 auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
 {
     using REACT_IMPL::SyncedIterateNode;
+    using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    using FuncType = typename std::decay<F>::type;
+
+    return CreateWrappedNode<Signal<S>, SyncedIterateNode<S, FuncType, E, Us ...>>(
+        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, signals) ...);
+}
+
+template <typename S, typename T, typename F, typename E, typename ... Us>
+auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
+{
     using REACT_IMPL::SyncedIterateByRefNode;
     using REACT_IMPL::IsCallableWith;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
 
     using FuncType = typename std::decay<F>::type;
-    using IterNodeType = typename std::conditional<
-        IsCallableWith<F, S, EventRange<E>, S, Us ...>::value,
-        SyncedIterateNode<S, FuncType, E, Us ...>,
-        SyncedIterateByRefNode<S, FuncType, E, Us ...>>::type;
 
-    return Signal<S>::CreateWithNode<IterNodeType>(
+    return CreateWrappedNode<Signal<S>, SyncedIterateByRefNode<S, FuncType, E, Us ...>>(
         group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, signals) ...);
 }
 
@@ -98,6 +133,10 @@ template <typename S, typename T, typename F, typename E, typename ... Us>
 auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
     { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, signals ...); }
 
+template <typename S, typename T, typename F, typename E, typename ... Us>
+auto IterateByRef(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
+    { return IterateByRef<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, signals ...); }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Snapshot - Sets signal value to value of other signal when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -105,7 +144,11 @@ template <typename S, typename E>
 auto Snapshot(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
 {
     using REACT_IMPL::SnapshotNode;
-    return Signal<S>::CreateWithNode<SnapshotNode<S, E>>(group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<Signal<S>, SnapshotNode<S, E>>(
+        group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename E>
@@ -119,7 +162,11 @@ template <typename S, typename E>
 auto Pulse(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
 {
     using REACT_IMPL::PulseNode;
-    return Event<S>::CreateWithNode<PulseNode<S, E>>(group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<Event<S>, PulseNode<S, E>>(
+        group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename E>
diff --git a/include/react/Event.h b/include/react/Event.h
index 5d97dfff..ff4a0a17 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,62 +9,18 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
-#include "react/API.h"
-#include "react/Group.h"
+#include "react/detail/defs.h"
+#include "react/api.h"
+#include "react/group.h"
+#include "react/common/ptrcache.h"
 
 #include <memory>
 #include <type_traits>
 #include <utility>
 
-#include "react/detail/graph/EventNodes.h"
+#include "react/detail/event_nodes.h"
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <typename E>
-class EventInternals
-{
-protected:
-    using NodeType = EventStreamNode<E>;
-    using StorageType = typename NodeType::StorageType;
-
-public:
-    EventInternals(const EventInternals&) = default;
-    EventInternals& operator=(const EventInternals&) = default;
-
-    EventInternals(EventInternals&&) = default;
-    EventInternals& operator=(EventInternals&&) = default;
-
-    EventInternals(std::shared_ptr<NodeType>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-        { }
-
-    auto GetNodePtr() -> std::shared_ptr<NodeType>&
-        { return nodePtr_; }
-
-    auto GetNodePtr() const -> const std::shared_ptr<NodeType>&
-        { return nodePtr_; }
-
-    NodeId GetNodeId() const
-        { return nodePtr_->GetNodeId(); }
 
-    StorageType& Events()
-        { return nodePtr_->Events(); }
-
-    const StorageType& Events() const
-        { return nodePtr_->Events(); }
-
-    void SetPendingSuccessorCount(size_t count)
-        { nodePtr_->SetPendingSuccessorCount(count); }
-
-    void DecrementPendingSuccessorCount()
-        { nodePtr_->DecrementPendingSuccessorCount(); }
-
-private:
-    std::shared_ptr<NodeType> nodePtr_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
@@ -81,41 +37,33 @@ class Event : protected REACT_IMPL::EventInternals<E>
     Event(Event&&) = default;
     Event& operator=(Event&&) = default;
 
+    // Construct with explicit group
     template <typename F, typename T>
-    Event(F&& func, const Event<T>& dep) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(dep.GetGroup(), std::forward<F>(func), dep) )
-        { }
+    Event(const Group& group, F&& func, const Event<T>& dep) :
+        Event::Event( CreateProcessingNode(group, std::forward<F>(func), dep) )
+    { }
 
+    // Construct with implicit group
     template <typename F, typename T>
-    Event(const Group& group, F&& func, const Event<T>& dep) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateProcessingNode(group, std::forward<F>(func), dep) )
-        { }
+    Event(F&& func, const Event<T>& dep) :
+        Event::Event( CreateProcessingNode(dep.GetGroup(), std::forward<F>(func), dep) )
+    { }
 
+    // Construct with explicit group
     template <typename F, typename T, typename ... Us>
-    Event(F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, signals ...) )
-        { }
+    Event(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
+        Event::Event( CreateSyncedProcessingNode(group, std::forward<F>(func), dep, signals ...) )
+    { }
 
+    // Construct with implicit group
     template <typename F, typename T, typename ... Us>
-    Event(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( REACT_IMPL::CtorTag{ }, CreateSyncedProcessingNode(group, std::forward<F>(func), dep, signals ...) )
-        { }
+    Event(F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
+        Event::Event( CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, signals ...) )
+    { }
 
     auto Tokenize() const -> decltype(auto)
         { return REACT::Tokenize(*this); }
 
-    /*template <typename ... Us>
-    auto Merge(Us&& ... deps) const -> decltype(auto)
-        { return REACT::Merge(*this, std::forward<Us>(deps) ...); }
-
-    template <typename F>
-    auto Filter(F&& pred) const -> decltype(auto)
-        { return REACT::Filter(std::forward<F>(pred), *this); }
-
-    template <typename F>
-    auto Transform(F&& pred) const -> decltype(auto)
-        { return REACT::Transform(*this, std::forward<F>(f)); }*/
-
     auto GetGroup() const -> const Group&
         { return GetNodePtr()->GetGroup(); }
 
@@ -134,18 +82,11 @@ class Event : protected REACT_IMPL::EventInternals<E>
     friend auto GetInternals(const Event<E>& e) -> const REACT_IMPL::EventInternals<E>&
         { return e; }
 
-public: // Internal
-    template <typename TNode, typename ... TArgs>
-    static Event<E> CreateWithNode(TArgs&& ... args)
-    {
-        return Event<E>( REACT_IMPL::CtorTag{ }, std::make_shared<TNode>(std::forward<TArgs>(args) ...) );
-    }
-
 protected:
     // Private node ctor
-    Event(REACT_IMPL::CtorTag, std::shared_ptr<REACT_IMPL::EventStreamNode<E>>&& nodePtr) :
+    explicit Event(std::shared_ptr<REACT_IMPL::EventStreamNode<E>>&& nodePtr) :
         Event::EventInternals( std::move(nodePtr) )
-        { }
+    { }
 
     template <typename F, typename T>
     auto CreateProcessingNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
@@ -166,6 +107,9 @@ class Event : protected REACT_IMPL::EventInternals<E>
         return std::make_shared<SyncedEventProcessingNode<E, T, typename std::decay<F>::type, Us ...>>(
             group, std::forward<F>(func), SameGroupOrLink(group, dep), SameGroupOrLink(group, syncs) ...);
     }
+
+    template <typename RET, typename NODE, typename ... ARGS>
+    friend static RET impl::CreateWrappedNode(ARGS&& ... args);
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -183,8 +127,8 @@ class EventSource : public Event<E>
 
     // Construct event source
     explicit EventSource(const Group& group) :
-        EventSource::Event( REACT_IMPL::CtorTag{ }, CreateSourceNode(group) )
-        { }
+        EventSource::Event( CreateSourceNode(group) )
+    { }
     
     void Emit(const E& value)
         { EmitValue(value); }
@@ -192,7 +136,7 @@ class EventSource : public Event<E>
     void Emit(E&& value)
         { EmitValue(std::move(value)); }
 
-    template <typename T = E, typename = typename std::enable_if<std::is_same<T,Token>::value>::type>
+    template <typename T = E, typename = std::enable_if_t<std::is_same_v<T,Token>>::type>
     void Emit()
         { EmitValue(Token::value); }
 
@@ -214,10 +158,10 @@ class EventSource : public Event<E>
     void EmitValue(T&& value)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::ReactiveGraph;
-        using SrcNodeType = REACT_IMPL::EventSourceNode<E>;
+        using REACT_IMPL::ReactGraph;
+        using REACT_IMPL::EventSourceNode;
 
-        SrcNodeType* castedPtr = static_cast<SrcNodeType*>(this->GetNodePtr().get());
+        auto* castedPtr = static_cast<EventSourceNode<E>*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
@@ -241,8 +185,8 @@ class EventSlot : public Event<E>
 
     // Construct emtpy slot
     EventSlot(const Group& group) :
-        EventSlot::Event( REACT_IMPL::CtorTag{ }, CreateSlotNode(group) )
-        { }
+        EventSlot::Event( CreateSlotNode(group) )
+    { }
 
     void Add(const Event<E>& input)
         { AddInput(input); }
@@ -316,50 +260,41 @@ class EventLink : public Event<E>
 
     // Construct with group
     EventLink(const Group& group, const Event<E>& input) :
-        EventLink::Event( REACT_IMPL::CtorTag{ }, GetOrCreateLinkNode(group, input) )
-        { }
+        EventLink::Event( GetOrCreateLinkNode(group, input) )
+    { }
 
 protected:
     static auto GetOrCreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::EventLinkNode;
-
-        auto& targetGraphPtr = GetInternals(group).GetGraphPtr();
-        auto& linkCache = targetGraphPtr->GetLinkCache();
+        using REACT_IMPL::IReactNode;
+        using REACT_IMPL::ReactGraph;
         
-        void* k1 = GetInternals(input.GetGroup()).GetGraphPtr().get();
-        void* k2 = GetInternals(input).GetNodePtr().get();
+        IReactNode* k = GetInternals(input).GetNodePtr().get();
+
+        ReactGraph::LinkCache& linkCache = GetInternals(group).GetGraphPtr()->GetLinkCache();
 
-        auto nodePtr = linkCache.LookupOrCreate<EventLinkNode<E>>(
-            { k1, k2 },
+        std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(
+            k,
             [&]
             {
                 auto nodePtr = std::make_shared<EventLinkNode<E>>(group, input);
                 nodePtr->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ nodePtr });
-                return nodePtr;
+                return std::static_pointer_cast<IReactNode>(nodePtr);
             });
 
-        return nodePtr;
+        return std::static_pointer_cast<EventLinkNode<E>>(nodePtr);
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T = void, typename U1, typename ... Us>
-auto Merge(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
+template <typename E, typename ... Us>
+auto Merge(const Group& group, const Event<E>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 {
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::SameGroupOrLink;
-    using REACT_IMPL::CtorTag;
-
-    static_assert(sizeof...(Us) > 0, "Merge requires at least 2 inputs.");
-
-    // If supplied, use merge type, otherwise default to common type.
-    using E = typename std::conditional<
-        std::is_same<T, void>::value,
-        typename std::common_type<U1, Us ...>::type,
-        T>::type;
 
     return Event<E>::CreateWithNode<EventMergeNode<E, U1, Us ...>>(group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
 }
@@ -433,17 +368,6 @@ template <typename E, typename F, typename T, typename ... Us>
 auto Transform(F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
     { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep, signals ...); }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/*template <typename TInnerValue>
-auto Flatten(const Signal<Events<TInnerValue>>& outer) -> Events<TInnerValue>
-{
-    return Events<TInnerValue>(
-        std::make_shared<REACT_IMPL::EventFlattenNode<Events<TInnerValue>, TInnerValue>>(
-            GetNodePtr(outer), GetNodePtr(outer.Value())));
-}*/
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/Group.h b/include/react/Group.h
index dd62b012..45ec476a 100644
--- a/include/react/Group.h
+++ b/include/react/Group.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,15 +9,16 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <memory>
 #include <utility>
 
 #include "react/API.h"
+#include "react/common/syncpoint.h"
 
-#include "react/detail/IReactiveGraph.h"
-#include "react/detail/graph/PropagationST.h"
+#include "react/detail/graph_interface.h"
+#include "react/detail/graph_impl.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
@@ -26,7 +27,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 class GroupInternals
 {
-    using GraphType = REACT_IMPL::ReactiveGraph;
+    using GraphType = REACT_IMPL::ReactGraph;
 
 public:
     GroupInternals() :
@@ -53,62 +54,6 @@ class GroupInternals
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
-#if 0
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TransactionStatus
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class TransactionStatus
-{
-    using StateT = REACT_IMPL::SharedWaitingState;
-    using PtrT = REACT_IMPL::WaitingStatePtrT;
-
-public:
-    // Default ctor
-    TransactionStatus() :
-        statePtr_( StateT::Create() )
-        { }
-
-    // Move ctor
-    TransactionStatus(TransactionStatus&& other) :
-        statePtr_( std::move(other.statePtr_) )
-    {
-        other.statePtr_ = StateT::Create();
-    }
-
-    // Move assignment
-    TransactionStatus& operator=(TransactionStatus&& other)
-    {
-        if (this != &other)
-        {
-            statePtr_ = std::move(other.statePtr_);
-            other.statePtr_ = StateT::Create();
-        }
-        return *this;
-    }
-
-    // Deleted copy ctor & assignment
-    TransactionStatus(const TransactionStatus&) = delete;
-    TransactionStatus& operator=(const TransactionStatus&) = delete;
-
-    void Wait()
-    {
-        assert(statePtr_.Get() != nullptr);
-        statePtr_->Wait();
-    }
-
-private:
-    PtrT statePtr_;
-
-    template <typename D, typename F>
-    friend void AsyncTransaction(TransactionStatus& status, F&& func);
-
-    template <typename D, typename F>
-    friend void AsyncTransaction(TransactionFlagsT flags, TransactionStatus& status, F&& func);
-};
-
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Group
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -128,12 +73,12 @@ class Group : protected REACT_IMPL::GroupInternals
         { GetGraphPtr()->DoTransaction(std::forward<F>(func)); }
 
     template <typename F>
-    void EnqueueTransaction(F&& func)
-        { EnqueueTransaction(TransactionFlags::none, std::forward<F>(func)); }
+    void EnqueueTransaction(F&& func, TransactionFlags flags = TransactionFlags::none)
+        { GetGraphPtr()->EnqueueTransaction(std::forward<F>(func), SyncPoint::Dependency{ }, flags); }
 
     template <typename F>
-    void EnqueueTransaction(TransactionFlags flags, F&& func)
-        { GetGraphPtr()->EnqueueTransaction(flags, std::forward<F>(func)); }
+    void EnqueueTransaction(F&& func, const SyncPoint& syncPoint, TransactionFlags flags = TransactionFlags::none)
+        { GetGraphPtr()->EnqueueTransaction(std::forward<F>(func), SyncPoint::Dependency{ syncPoint }, flags); }
 
     friend bool operator==(const Group& a, const Group& b)
         { return a.GetGraphPtr() == b.GetGraphPtr(); }
diff --git a/include/react/Observer.h b/include/react/Observer.h
index a2ff497a..1f28136d 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,21 +9,54 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
-#include "react/API.h"
-#include "react/Group.h"
+#include "react/detail/defs.h"
+#include "react/api.h"
+#include "react/group.h"
 
 #include <memory>
 #include <utility>
 
-#include "react/detail/graph/ObserverNodes.h"
+#include "react/detail/observer_nodes.h"
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+class ObserverInternals
+{
+public:
+    ObserverInternals(const ObserverInternals&) = default;
+    ObserverInternals& operator=(const ObserverInternals&) = default;
+
+    ObserverInternals(ObserverInternals&&) = default;
+    ObserverInternals& operator=(ObserverInternals&&) = default;
+
+    explicit ObserverInternals(std::shared_ptr<ObserverNode>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+    { }
+
+    auto GetNodePtr() -> std::shared_ptr<ObserverNode>&
+        { return nodePtr_; }
+
+    auto GetNodePtr() const -> const std::shared_ptr<ObserverNode>&
+        { return nodePtr_; }
+
+    NodeId GetNodeId() const
+        { return nodePtr_->GetNodeId(); }
+
+protected:
+    ObserverInternals() = default;
+
+private:
+    std::shared_ptr<ObserverNode> nodePtr_;
+};
+
+/****************************************/ REACT_IMPL_END /***************************************/
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ObserverBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class Observer
+class Observer : protected REACT_IMPL::ObserverInternals
 {
 private:
     using NodeType = REACT_IMPL::ObserverNode;
@@ -38,50 +71,44 @@ class Observer
     // Construct signal observer with explicit group
     template <typename F, typename T1, typename ... Ts>
     Observer(const Group& group, F&& func, const Signal<T1>& subject1, const Signal<Ts>& ... subjects) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(group, std::forward<F>(func), subject1, subjects ...))
-        { }
+        Observer::Observer( CreateSignalObserverNode(group, std::forward<F>(func), subject1, subjects ...))
+    { }
 
     // Construct signal observer with implicit group
     template <typename F, typename T1, typename ... Ts>
     Observer(F&& func, const Signal<T1>& subject1, const Signal<Ts>& ... subjects) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSignalObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...))
-        { }
+        Observer::Observer( CreateSignalObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...))
+    { }
 
     // Construct event observer with explicit group
     template <typename F, typename T>
     Observer(const Group& group, F&& func, const Event<T>& subject) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(group, std::forward<F>(func), subject))
-        { }
+        Observer::Observer( CreateEventObserverNode(group, std::forward<F>(func), subject))
+    { }
 
     // Construct event observer with implicit group
     template <typename F, typename T>
     Observer(F&& func, const Event<T>& subject) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject))
-        { }
+        Observer::Observer( CreateEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject))
+    { }
 
     // Constructed synced event observer with explicit group
     template <typename F, typename T, typename ... Us>
     Observer(const Group& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, signals ...))
-        { }
+        Observer::Observer( CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, signals ...))
+    { }
 
     // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
     Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer(REACT_IMPL::CtorTag{ }, CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, signals ...))
-        { }
+        Observer::Observer( CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, signals ...))
+    { }
 
 public: //Internal
     // Private node ctor
-    Observer(REACT_IMPL::CtorTag, std::shared_ptr<NodeType>&& nodePtr) :
+    explicit Observer(std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_(std::move(nodePtr))
-        { }
-
-    auto NodePtr() -> std::shared_ptr<NodeType>&
-        { return nodePtr_; }
-
-    auto NodePtr() const -> const std::shared_ptr<NodeType>&
-        { return nodePtr_; }
+    { }
 
 protected:
     template <typename F, typename T1, typename ... Ts>
diff --git a/include/react/Signal.h b/include/react/Signal.h
index a429f34b..c7e11e8f 100644
--- a/include/react/Signal.h
+++ b/include/react/Signal.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,53 +9,18 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
-#include "react/API.h"
-#include "react/Group.h"
+#include "react/detail/defs.h"
+#include "react/api.h"
+#include "react/group.h"
+#include "react/common/ptrcache.h"
 
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
-#include "react/detail/graph/SignalNodes.h"
+#include "react/detail/signal_nodes.h"
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <typename S>
-class SignalInternals
-{
-public:
-    SignalInternals(const SignalInternals&) = default;
-    SignalInternals& operator=(const SignalInternals&) = default;
-
-    SignalInternals(SignalInternals&&) = default;
-    SignalInternals& operator=(SignalInternals&&) = default;
-
-    SignalInternals(std::shared_ptr<SignalNode<S>>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-        { }
-
-    auto GetNodePtr() -> std::shared_ptr<SignalNode<S>>&
-        { return nodePtr_; }
-
-    auto GetNodePtr() const -> const std::shared_ptr<SignalNode<S>>&
-        { return nodePtr_; }
-
-    NodeId GetNodeId() const
-        { return nodePtr_->GetNodeId(); }
-
-    S& Value()
-        { return nodePtr_->Value(); }
-
-    const S& Value() const
-        { return nodePtr_->Value(); }
-
-private:
-    std::shared_ptr<SignalNode<S>> nodePtr_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
@@ -76,13 +41,13 @@ class Signal : protected REACT_IMPL::SignalInternals<S>
     template <typename F, typename T1, typename ... Ts>
     explicit Signal(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
         Signal::SignalInternals( CreateFuncNode(group, std::forward<F>(func), dep1, deps ...) )
-        { }
+    { }
 
     // Construct with implicit group
     template <typename F, typename T1, typename ... Ts>
     explicit Signal(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
         Signal::SignalInternals( CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...) )
-        { }
+    { }
 
     auto GetGroup() const -> const Group&
         { return this->GetNodePtr()->GetGroup(); }
@@ -102,23 +67,24 @@ class Signal : protected REACT_IMPL::SignalInternals<S>
     friend auto GetInternals(const Signal<S>& s) -> const REACT_IMPL::SignalInternals<S>&
         { return s; }
 
-    template <typename TNode, typename ... TArgs>
-    static Signal<S> CreateWithNode(TArgs&& ... args)
-        { return Signal<S>( REACT_IMPL::CtorTag{ }, std::make_shared<TNode>(std::forward<TArgs>(args) ...) ); }
-
 protected:
-    Signal(REACT_IMPL::CtorTag, std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
+    explicit Signal(std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
         Signal::SignalInternals( std::move(nodePtr) )
-        { }
+    { }
 
+private:
     template <typename F, typename T1, typename ... Ts>
     auto CreateFuncNode(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::SignalFuncNode;
+        using REACT_IMPL::SameGroupOrLink;
 
         return std::make_shared<SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>>(
             group, std::forward<F>(func), SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
     }
+
+    template <typename RET, typename NODE, typename ... ARGS>
+    friend RET impl::CreateWrappedNode(ARGS&& ... args);
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -136,14 +102,14 @@ class VarSignal : public Signal<S>
 
     // Construct with group + default
     explicit VarSignal(const Group& group) :
-        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(group) )
-        { }
+        VarSignal::Signal( CreateVarNode(group) )
+    { }
 
     // Construct with group + value
     template <typename T>
     VarSignal(const Group& group, T&& value) :
-        VarSignal::Signal( REACT_IMPL::CtorTag{ }, CreateVarNode(group, std::forward<T>(value)) )
-        { }
+        VarSignal::Signal( CreateVarNode(group, std::forward<T>(value)) )
+    { }
 
     void Set(const S& newValue)
         { SetValue(newValue); }
@@ -151,12 +117,6 @@ class VarSignal : public Signal<S>
     void Set(S&& newValue)
         { SetValue(std::move(newValue)); }
 
-    void operator<<=(const S& newValue)
-        { SetValue(newValue); }
-
-    void operator<<=(S&& newValue)
-        { SetValue(std::move(newValue)); }
-
     template <typename F>
     void Modify(const F& func)
         { ModifyValue(func); }
@@ -168,6 +128,11 @@ class VarSignal : public Signal<S>
         { return !(a == b); }
 
 protected:
+    explicit VarSignal(std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
+        VarSignal::Signal( std::move(nodePtr) )
+    { }
+
+private:
     static auto CreateVarNode(const Group& group) -> decltype(auto)
     {
         using REACT_IMPL::VarSignalNode;
@@ -181,7 +146,6 @@ class VarSignal : public Signal<S>
         return std::make_shared<VarSignalNode<S>>(group, std::forward<T>(value));
     }
 
-private:
     template <typename T>
     void SetValue(T&& newValue)
     {
@@ -226,13 +190,13 @@ class SignalSlot : public Signal<S>
 
     // Construct with explicit group
     SignalSlot(const Group& group, const Signal<S>& input) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(group, input) )
-        { }
+        SignalSlot::Signal( CreateSlotNode(group, input) )
+    { }
 
     // Construct with implicit group
     explicit SignalSlot(const Signal<S>& input) :
-        SignalSlot::Signal( REACT_IMPL::CtorTag{ }, CreateSlotNode(input.GetGroup(), input) )
-        { }
+        SignalSlot::Signal( CreateSlotNode(input.GetGroup(), input) )
+    { }
 
     void Set(const Signal<S>& newInput)
         { SetInput(newInput); }
@@ -241,19 +205,26 @@ class SignalSlot : public Signal<S>
         { SetInput(newInput); }
 
 protected:
+    explicit SignalSlot(std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
+        SignalSlot::Signal( std::move(nodePtr) )
+    { }
+
+private:
     static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::SignalSlotNode;
+        using REACT_IMPL::SameGroupOrLink;
+
         return std::make_shared<SignalSlotNode<S>>(group, SameGroupOrLink(group, input));
     }
 
-private:
     void SetInput(const Signal<S>& newInput)
     {
         using REACT_IMPL::NodeId;
-        using SlotNodeType = REACT_IMPL::SignalSlotNode<S>;
+        using REACT_IMPL::SignalSlotNode;
+        using REACT_IMPL::SameGroupOrLink;
 
-        SlotNodeType* castedPtr = static_cast<SlotNodeType*>(this->GetNodePtr().get());
+        auto* castedPtr = static_cast<SignalSlotNode<S>*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
@@ -277,31 +248,30 @@ class SignalLink : public Signal<S>
 
     // Construct with group
     SignalLink(const Group& group, const Signal<S>& input) :
-        SignalLink::Signal( REACT_IMPL::CtorTag{ }, GetOrCreateLinkNode(group, input) )
-        { }
+        SignalLink::Signal( GetOrCreateLinkNode(group, input) )
+    { }
 
 protected:
     static auto GetOrCreateLinkNode(const Group& group, const Signal<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::SignalLinkNode;
-
-        auto targetGraphPtr = GetInternals(group).GetGraphPtr();
+        using REACT_IMPL::IReactNode;
+        using REACT_IMPL::ReactGraph;
         
-        void* k1 = GetInternals(input.GetGroup()).GetGraphPtr().get();
-        void* k2 = GetInternals(input).GetNodePtr().get();
+        IReactNode* k = GetInternals(input).GetNodePtr().get();
 
-        auto& linkCache = targetGraphPtr->GetLinkCache();
+        ReactGraph::LinkCache& linkCache = GetInternals(group).GetGraphPtr()->GetLinkCache();
 
-        auto nodePtr = linkCache.LookupOrCreate<SignalLinkNode<S>>(
-            { k1, k2 },
+        std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(
+            k,
             [&]
             {
                 auto nodePtr = std::make_shared<SignalLinkNode<S>>(group, input);
                 nodePtr->SetWeakSelfPtr(std::weak_ptr<SignalLinkNode<S>>{ nodePtr });
-                return nodePtr;
+                return std::static_pointer_cast<IReactNode>(nodePtr);
             });
 
-        return nodePtr;
+        return std::static_pointer_cast<SignalLinkNode<S>>(nodePtr);
     }
 };
 
diff --git a/include/react/common/Concurrency.h b/include/react/common/Concurrency.h
deleted file mode 100644
index 0a5c350c..00000000
--- a/include/react/common/Concurrency.h
+++ /dev/null
@@ -1,324 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_CONCURRENCY_H_INCLUDED
-#define REACT_COMMON_CONCURRENCY_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <condition_variable>
-#include <mutex>
-
-#include "react/common/RefCounting.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IWaitingState
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class IWaitingState
-{
-public:
-    virtual inline ~IWaitingState() {}
-
-    virtual void Wait() = 0;
-
-    virtual void IncWaitCount() = 0;
-    virtual void DecWaitCount() = 0;
-
-protected:
-    virtual bool IsRefCounted() const = 0;
-    virtual void IncRefCount() = 0;
-    virtual void DecRefCount() = 0;
-
-    friend class IntrusiveRefCountingPtr<IWaitingState>;
-};
-
-using WaitingStatePtrT = IntrusiveRefCountingPtr<IWaitingState>;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// WaitingStateBase
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class WaitingStateBase : public IWaitingState
-{
-public:
-    virtual inline void Wait() override
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        condition_.wait(lock, [this] { return !isWaiting_; });
-    }
-
-    virtual inline void IncWaitCount() override
-    {
-        auto oldVal = waitCount_.fetch_add(1, std::memory_order_relaxed);
-
-        if (oldVal == 0)
-        {// mutex_
-            std::lock_guard<std::mutex> scopedLock(mutex_);
-            isWaiting_ = true;
-        }// ~mutex_
-    }
-
-    virtual inline void DecWaitCount() override
-    {
-        auto oldVal = waitCount_.fetch_sub(1, std::memory_order_relaxed);
-
-        if (oldVal == 1)
-        {// mutex_
-            std::lock_guard<std::mutex> scopedLock(mutex_);
-            isWaiting_ = false;
-            condition_.notify_all();
-        }// ~mutex_
-    }
-
-    inline bool IsWaiting()
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-        return isWaiting_;
-    }// ~mutex_
-
-    template <typename F>
-    auto Run(F&& func) -> decltype(func(false))
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-        return func(isWaiting_);
-    }// ~mutex_
-
-    template <typename F>
-    bool RunIfWaiting(F&& func)
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-
-        if (!isWaiting_)
-            return false;
-
-        func();
-        return true;            
-    }// ~mutex_
-
-    template <typename F>
-    bool RunIfNotWaiting(F&& func)
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-
-        if (isWaiting_)
-            return false;
-
-        func();
-        return true;            
-    }// ~mutex_
-
-private:
-    std::atomic<uint>           waitCount_{ 0 };
-    std::condition_variable     condition_;
-    std::mutex                  mutex_;
-    bool                        isWaiting_ = false;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// UniqueWaitingState
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class UniqueWaitingState : public WaitingStateBase
-{
-protected:
-    // Do nothing
-    virtual inline bool IsRefCounted() const override { return false; }
-    virtual inline void IncRefCount() override {} 
-    virtual inline void DecRefCount() override {}
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SharedWaitingState
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class SharedWaitingState : public WaitingStateBase
-{
-private:
-    SharedWaitingState() = default;
-
-public:
-    static inline WaitingStatePtrT Create()
-    {
-        return WaitingStatePtrT(new SharedWaitingState());
-    }
-
-
-protected:
-    virtual inline bool IsRefCounted() const override { return true; }
-
-    virtual inline void IncRefCount() override
-    {
-        refCount_.fetch_add(1, std::memory_order_relaxed);
-    }
-
-    virtual inline void DecRefCount() override
-    {
-        auto oldVal = refCount_.fetch_sub(1, std::memory_order_relaxed);
-
-        if (oldVal == 1)
-            delete this;
-    }
-
-private:
-    std::atomic<uint>           refCount_{ 0 };
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SharedWaitingStateCollection
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class SharedWaitingStateCollection : public IWaitingState
-{
-private:
-    SharedWaitingStateCollection(std::vector<WaitingStatePtrT>&& others) :
-        others_( std::move(others) )
-    {}
-
-public:
-    static inline WaitingStatePtrT Create(std::vector<WaitingStatePtrT>&& others)
-    {
-        return WaitingStatePtrT(new SharedWaitingStateCollection(std::move(others)));
-    }
-
-    virtual inline bool IsRefCounted() const override { return true; }
-
-    virtual inline void Wait() override
-    {
-        for (const auto& e : others_)
-            e->Wait();
-    }
-
-    virtual inline void IncWaitCount() override
-    {
-        for (const auto& e : others_)
-            e->IncWaitCount();
-    }
-
-    virtual inline void DecWaitCount() override
-    {
-        for (const auto& e : others_)
-            e->DecWaitCount();
-    }
-
-    virtual inline void IncRefCount() override
-    {
-        refCount_.fetch_add(1, std::memory_order_relaxed);
-    }
-
-    virtual inline void DecRefCount() override
-    {
-        auto oldVal = refCount_.fetch_sub(1, std::memory_order_relaxed);
-
-        if (oldVal == 1)
-            delete this;
-    }
-
-private:
-    std::atomic<uint>               refCount_{ 0 };
-    std::vector<WaitingStatePtrT>   others_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// BlockingCondition
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class BlockingCondition
-{
-public:
-    inline void Block()
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-        blocked_ = true;
-    }// ~mutex_
-
-    inline void Unblock()
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-        blocked_ = false;
-        condition_.notify_all();
-    }// ~mutex_
-
-    inline void WaitForUnblock()
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        condition_.wait(lock, [this] { return !blocked_; });
-    }
-
-    inline bool IsBlocked()
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-        return blocked_;
-    }// ~mutex_
-
-    template <typename F>
-    auto Run(F&& func) -> decltype(func(false))
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-        return func(blocked_);
-    }// ~mutex_
-
-    template <typename F>
-    bool RunIfBlocked(F&& func)
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-
-        if (!blocked_)
-            return false;
-
-        func();
-        return true;            
-    }// ~mutex_
-
-    template <typename F>
-    bool RunIfUnblocked(F&& func)
-    {// mutex_
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-
-        if (blocked_)
-            return false;
-
-        func();
-        return true;            
-    }// ~mutex_
-
-private:
-    std::mutex                  mutex_;
-    std::condition_variable     condition_;
-
-    bool    blocked_ = false;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ConditionalCriticalSection
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TMutex, bool is_enabled>
-class ConditionalCriticalSection;
-
-template <typename TMutex>
-class ConditionalCriticalSection<TMutex,false>
-{
-public:
-    template <typename F>
-    void Access(const F& f) { f(); }
-};
-
-template <typename TMutex>
-class ConditionalCriticalSection<TMutex,true>
-{
-public:
-    template <typename F>
-    void Access(const F& f)
-    {// mutex_
-        std::lock_guard<TMutex> lock(mutex_);
-
-        f();
-    }// ~mutex_
-private:
-    TMutex  mutex_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_COMMON_CONCURRENCY_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/RefCounting.h b/include/react/common/RefCounting.h
index f2cd518a..37bb5e68 100644
--- a/include/react/common/RefCounting.h
+++ b/include/react/common/RefCounting.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <condition_variable>
 #include <mutex>
diff --git a/include/react/common/SourceIdSet.h b/include/react/common/SourceIdSet.h
index b1a3eeb0..902a39aa 100644
--- a/include/react/common/SourceIdSet.h
+++ b/include/react/common/SourceIdSet.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <algorithm>
 #include <vector>
diff --git a/include/react/common/Timing.h b/include/react/common/Timing.h
index 84c58006..7d6c81ac 100644
--- a/include/react/common/Timing.h
+++ b/include/react/common/Timing.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <utility>
 
diff --git a/include/react/common/TopoQueue.h b/include/react/common/TopoQueue.h
index 091d116f..2c3c4613 100644
--- a/include/react/common/TopoQueue.h
+++ b/include/react/common/TopoQueue.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <algorithm>
 #include <array>
diff --git a/include/react/common/Types.h b/include/react/common/Types.h
index 0545f858..30a377fa 100644
--- a/include/react/common/Types.h
+++ b/include/react/common/Types.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <chrono>
 #include <cstdint>
diff --git a/include/react/common/Util.h b/include/react/common/Util.h
deleted file mode 100644
index 4721723d..00000000
--- a/include/react/common/Util.h
+++ /dev/null
@@ -1,249 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_UTIL_H_INCLUDED
-#define REACT_COMMON_UTIL_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <typename ... Ts>
-struct MakeVoid { using type = void;};
-
-template <typename ... Ts>
-using VoidType = typename MakeVoid<Ts ...>::type;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Unpack tuple - see
-/// http://stackoverflow.com/questions/687490/how-do-i-expand-a-tuple-into-variadic-template-functions-arguments
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-template<size_t N>
-struct Apply {
-    template<typename F, typename T, typename... A>
-    static auto apply(F&& f, T&& t, A&&... a) -> decltype(auto)
-    {
-        return Apply<N-1>::apply(std::forward<F>(f), std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
-    }
-};
-
-template<>
-struct Apply<0>
-{
-    template<typename F, typename T, typename... A>
-    static auto apply(F&& f, T&&, A&&... a) -> decltype(auto)
-    {
-        return std::forward<F>(f)(std::forward<A>(a)...);
-    }
-};
-
-template<typename F, typename T>
-inline auto apply(F&& f, T&& t) -> decltype(auto)
-{
-    return Apply<std::tuple_size<typename std::decay<T>::type>::value>::apply(std::forward<F>(f), std::forward<T>(t));
-}
-
-template<size_t N>
-struct ApplyMemberFn {
-    template <typename O, typename F, typename T, typename... A>
-    static inline auto apply(O obj, F f, T && t, A &&... a) -> decltype(auto)
-    {
-        return ApplyMemberFn<N-1>::apply(obj, f, std::forward<T>(t), std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
-    }
-};
-
-template<>
-struct ApplyMemberFn<0>
-{
-    template<typename O, typename F, typename T, typename... A>
-    static inline auto apply(O obj, F f, T &&, A &&... a)
-        -> decltype((obj->*f)(std::forward<A>(a)...))
-    {
-        return (obj->*f)(std::forward<A>(a)...);
-    }
-};
-
-template <typename O, typename F, typename T>
-inline auto applyMemberFn(O obj, F f, T&& t)
-    -> decltype(ApplyMemberFn<std::tuple_size<typename std::decay<T>::type>::value>::apply(obj, f, std::forward<T>(t)))
-{
-    return ApplyMemberFn<std::tuple_size<typename std::decay<T>::type>::value>
-        ::apply(obj, f, std::forward<T>(t));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Helper to enable calling a function on each element of an argument pack.
-/// We can't do f(args) ...; because ... expands with a comma.
-/// But we can do nop_func(f(args) ...);
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename... TArgs>
-inline void pass(TArgs&& ...) {}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Identity (workaround to enable enable decltype()::X)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct Identity
-{
-    using Type = T;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DontMove!
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct DontMove {};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DisableIfSame
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, typename U>
-struct DisableIfSame :
-    std::enable_if<! std::is_same<
-        typename std::decay<T>::type,
-        typename std::decay<U>::type>::value> {};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AddDummyArgWrapper
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TArg, typename F, typename TRet, typename ... TDepValues>
-struct AddDummyArgWrapper
-{
-    AddDummyArgWrapper(const AddDummyArgWrapper& other) = default;
-
-    AddDummyArgWrapper(AddDummyArgWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template <typename FIn, class = typename DisableIfSame<FIn,AddDummyArgWrapper>::type>
-    explicit AddDummyArgWrapper(FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
-
-    TRet operator()(TArg, TDepValues& ... args)
-    {
-        return MyFunc(args ...);
-    }
-
-    F MyFunc;
-};
-
-template <typename TArg, typename F, typename ... TDepValues>
-struct AddDummyArgWrapper<TArg,F,void,TDepValues...>
-{
-public:
-    AddDummyArgWrapper(const AddDummyArgWrapper& other) = default;
-
-    AddDummyArgWrapper(AddDummyArgWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template <typename FIn, class = typename DisableIfSame<FIn,AddDummyArgWrapper>::type>
-    explicit AddDummyArgWrapper(FIn&& func) : MyFunc( std::forward<FIn>(func) ) {}
-
-    void operator()(TArg, TDepValues& ... args)
-    {
-        MyFunc(args ...);
-    }
-
-    F MyFunc;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AddDefaultReturnValueWrapper
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template 
-<
-    typename F,
-    typename TRet,
-    TRet return_value
->
-struct AddDefaultReturnValueWrapper
-{
-    AddDefaultReturnValueWrapper(const AddDefaultReturnValueWrapper&) = default;
-
-    AddDefaultReturnValueWrapper(AddDefaultReturnValueWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template
-    <
-        typename FIn,
-        class = typename DisableIfSame<FIn,AddDefaultReturnValueWrapper>::type
-    >
-    explicit AddDefaultReturnValueWrapper(FIn&& func) :
-        MyFunc( std::forward<FIn>(func) )
-    {}
-
-    template <typename ... TArgs>
-    TRet operator()(TArgs&& ... args)
-    {
-        MyFunc(std::forward<TArgs>(args) ...);
-        return return_value;
-    }
-
-    F MyFunc;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IsCallableWith
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename F, typename TRet, typename ... TArgs>
-class IsCallableWith
-{
-private:
-    using NoT = char[1];
-    using YesT = char[2];
-
-    template
-    <
-        typename U,
-        typename = decltype(static_cast<TRet>((std::declval<U>())(std::declval<TArgs>() ...)))
-    >
-    static YesT& check(void*);
-
-    template <typename U>
-    static NoT& check(...);
-
-public:
-    static const bool value = sizeof(check<F>(nullptr)) == sizeof(YesT);
-};
-
-template <typename T>
-bool IsBitmaskSet(T flags, T mask)
-{
-    return (flags & mask) != (T)0;
-}
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-// Expand args by wrapping them in a dummy function
-// Use comma operator to replace potential void return value with 0
-#define REACT_EXPAND_PACK(...) REACT_IMPL::pass((__VA_ARGS__ , 0) ...)
-
-#define REACT_DEFINE_BITMASK_OPERATORS(t) \
-    inline t operator|(t lhs, t rhs) \
-        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); } \
-    inline t operator&(t lhs, t rhs) \
-        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) & static_cast<std::underlying_type<t>::type>(rhs)); } \
-    inline t operator^(t lhs, t rhs) \
-        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); } \
-    inline t operator~(t rhs) \
-        { return static_cast<t>(~static_cast<std::underlying_type<t>::type>(rhs)); } \
-    inline t& operator|=(t& lhs, t rhs) \
-        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); return lhs; } \
-    inline t& operator&=(t& lhs, t rhs) \
-        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) & static_cast<std::underlying_type<t>::type>(rhs)); return lhs; } \
-    inline t& operator^=(t& lhs, t rhs) \
-        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); return lhs; }
-
-// Bitmask helper
-
-#endif // REACT_COMMON_UTIL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/expected.h b/include/react/common/expected.h
new file mode 100644
index 00000000..5bdff539
--- /dev/null
+++ b/include/react/common/expected.h
@@ -0,0 +1,218 @@
+
+//          Copyright Sebastian Jeckel 2016.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_COMMON_EXPECTED_H_INCLUDED
+#define REACT_COMMON_EXPECTED_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/Defs.h"
+
+#include <string>
+#include <sstream>
+#include <memory>
+#include <type_traits>
+
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// IError
+///////////////////////////////////////////////////////////////////////////////////////////////////
+class IErrorCause
+{
+public:
+    virtual ~IErrorCause() = default;
+
+    virtual std::string GetMessage() const = 0;
+
+    virtual bool IsOfType(const char* typeId) const = 0;
+};
+
+
+class AllocationError : public IErrorCause
+{
+public:
+    static constexpr const char* type_id = "react::AllocationError";
+
+    virtual std::string GetMessage() const
+        { return "Allocation error."; }
+
+    virtual bool IsOfType(const char* typeId) const
+        { return typeId == type_id; }
+};
+
+
+class PreconditionError : public IErrorCause
+{
+public:
+    static constexpr const char* type_id = "react::PreconditionError";
+
+    virtual std::string GetMessage() const
+        { return "Precondition error."; }
+
+    virtual bool IsOfType(const char* typeId) const
+        { return typeId == type_id; }
+};
+
+
+class PostconditionError : public IErrorCause
+{
+public:
+    static constexpr const char* type_id = "react::PostconditionError";
+
+    virtual std::string GetMessage() const
+        { return "Postcondition error."; }
+
+    virtual bool IsOfType(const char* typeId) const
+        { return typeId == type_id; }
+};
+
+
+class MissingValueError : public IErrorCause
+{
+public:
+    static constexpr const char* type_id = "react::MissingValueError";
+
+    virtual std::string GetMessage() const
+        { return "Missing value error."; }
+
+    virtual bool IsOfType(const char* typeId) const
+        { return typeId == type_id; }
+};
+
+
+class Error
+{
+public:
+    template
+    <
+        typename T,
+        typename = std::enable_if_t<std::is_base_of_v<IErrorCause, T>>
+    >
+    Error(T cause) :
+        cause_(std::make_shared<T>(std::move(cause)))
+    { }
+
+    template
+    <
+        typename T,
+        typename = std::enable_if_t<std::is_base_of_v<IErrorCause, T>>
+    >
+    bool IsCause() const
+        { return cause_->IsOfType(T::type_id); }
+
+    template
+    <
+        typename T,
+        typename = std::enable_if_t<std::is_base_of_v<IErrorCause, T>>
+    >
+    T* GetCause() const
+        { return static_cast<T*>(cause_.get()); }
+
+    std::string GetMessage() const
+        { return cause_->GetMessage(); }
+
+private:
+    std::shared_ptr<const IErrorCause> cause_;
+};
+
+static Error* GetErrorSentinel()
+    { return reinterpret_cast<Error*>(0x1u); }
+
+struct ErrorDeleter
+{
+    void operator()(Error* p) const
+    {
+        if (p != GetErrorSentinel())
+            delete p;
+    }
+};
+
+using UniqueErrorPtrType = std::unique_ptr<Error, ErrorDeleter>;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Expected
+///
+/// TODO: Optimize for different storage types to avoid branch in destructor.
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+class Expected
+{
+public:
+    Expected() = delete;
+
+    Expected(const Expected&) = delete;
+
+    Expected& operator=(const Expected&) = delete;
+
+    Expected(Expected&&) = default;
+
+    Expected& operator=(Expected&&) = default;
+
+    Expected(const T& value) :
+        error_( GetErrorSentinel() )
+    {
+        ValueRef() = value;
+    }
+
+    Expected(T&& value) :
+        error_( GetErrorSentinel() )
+    {
+        ValueRef() = std::move(value);
+    }
+
+    Expected(Error err) :
+        error_(new Error(std::move(err)))
+    { }
+
+    Expected(UniqueErrorPtrType&& err) :
+        error_(std::move(err))
+    { }
+
+    ~Expected()
+    {
+        if (error_.get() == GetErrorSentinel())
+        {
+            Destruct();
+        }   
+    }
+
+    explicit operator bool() const
+    {
+        return error_.get() == GetErrorSentinel();
+    }
+
+    Error GetError()
+        { return *error_; }
+
+private:
+    const T& ValueRef() const
+        { return *reinterpret_cast<T*>(&valueStorage_); }
+
+    T& ValueRef()
+        { return *reinterpret_cast<T*>(&valueStorage_); }
+
+    void Destruct()
+        { reinterpret_cast<const T*>(&valueStorage_)->~T(); }
+
+    std::aligned_storage_t<sizeof(T)> valueStorage_;
+
+    std::unique_ptr<Error, ErrorDeleter> error_;
+
+    template <typename U>
+    friend typename UniqueErrorPtrType UnwindExpected(Expected<U>&& ex);
+};
+
+template <typename T>
+typename UniqueErrorPtrType UnwindExpected(Expected<T>&& ex)
+{
+    return std::move(std::move(ex).error_);
+}
+
+/******************************************/ REACT_END /******************************************/
+
+#endif // REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/optional.h b/include/react/common/optional.h
new file mode 100644
index 00000000..3208c33b
--- /dev/null
+++ b/include/react/common/optional.h
@@ -0,0 +1,70 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_COMMON_OPTIONAL_H_INCLUDED
+#define REACT_COMMON_OPTIONAL_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/defs.h"
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
+struct NoValueType
+{
+    struct Tag {};
+
+    explicit constexpr NoValueType(Tag)
+    { }
+};
+
+constexpr NoValueType no_value{ NoValueType::Tag{ } };
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+template <typename T>
+class OptScalarStorage
+{
+public:
+    OptScalarStorage() : hasValue_( false )
+    { }
+
+    OptScalarStorage(NoValueType) : hasValue_( false )
+    { }
+
+    OptScalarStorage& operator=(NoValueType)
+    {
+        hasValue_ = false;
+        return *this;
+    }
+
+    OptScalarStorage(const OptScalarStorage&) = default;
+
+    OptScalarStorage& operator=(const OptScalarStorage&) = default;
+
+    bool HasValue() const
+        { return hasValue_; }
+
+    const T& Value() const
+        { return value_; }
+
+    T& Value()
+        { return value_; }
+
+private:
+    T       value_;
+    bool    hasValue_;
+};
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+/******************************************/ REACT_END /******************************************/
+
+#endif // REACT_COMMON_OPTIONAL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/owned_ptr.h b/include/react/common/owned_ptr.h
new file mode 100644
index 00000000..f0d06bcb
--- /dev/null
+++ b/include/react/common/owned_ptr.h
@@ -0,0 +1,18 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_COMMON_OWNED_PTR_H_INCLUDED
+#define REACT_COMMON_OWNED_PTR_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/Defs.h"
+
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+/******************************************/ REACT_END /******************************************/
+
+#endif // REACT_COMMON_OWNED_PTR_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/ptrcache.h b/include/react/common/ptrcache.h
new file mode 100644
index 00000000..50d71584
--- /dev/null
+++ b/include/react/common/ptrcache.h
@@ -0,0 +1,65 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_COMMON_PTR_CACHE_H_INCLUDED
+#define REACT_COMMON_PTR_CACHE_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/Defs.h"
+
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Stores weak pointers to V indexed by K.
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename K, typename V>
+class WeakPtrCache
+{
+public:
+    template <typename F>
+    std::shared_ptr<V> LookupOrCreate(const K& key, F&& createFunc)
+    {
+        std::lock_guard<std::mutex> scopedLock(mutex_);
+
+        auto it = map_.find(key);
+        if (it != map_.end())
+        {
+            if (auto ptr = it->second.lock())
+            {
+                return ptr;
+            }
+        }
+
+        std::shared_ptr<V> v = createFunc();
+        auto res = map_.emplace(key, v);
+        return v;
+    }
+
+    void Erase(const K& key)
+    {
+        std::lock_guard<std::mutex> scopedLock(mutex_);
+
+        auto it = map_.find(key);
+        if (it != map_.end())
+        {
+            map_.erase(it);
+        }
+    }
+
+private:
+    std::mutex mutex_;
+    std::unordered_map<K, std::weak_ptr<V>> map_;
+};
+
+
+/******************************************/ REACT_END /******************************************/
+
+#endif // REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/Containers.h b/include/react/common/slotmap.h
similarity index 82%
rename from include/react/common/Containers.h
rename to include/react/common/slotmap.h
index 79980acf..c0282ec0 100644
--- a/include/react/common/Containers.h
+++ b/include/react/common/slotmap.h
@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_COMMON_CONTAINERS_H_INCLUDED
-#define REACT_COMMON_CONTAINERS_H_INCLUDED
+#ifndef REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
+#define REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
 
 #pragma once
 
@@ -17,13 +17,13 @@
 #include <memory>
 #include <type_traits>
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
+/*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IndexMap
+/// SlotMap
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
-class IndexedStorage
+class SlotMap
 {
     static const size_t initial_capacity = 8;
     static const size_t grow_factor = 2;
@@ -33,15 +33,15 @@ class IndexedStorage
 public:
     using ValueType = T;
 
-    IndexedStorage() = default;
+    SlotMap() = default;
 
-    IndexedStorage(IndexedStorage&&) = default;
-    IndexedStorage& operator=(IndexedStorage&&) = default;
+    SlotMap(SlotMap&&) = default;
+    SlotMap& operator=(SlotMap&&) = default;
 
-    IndexedStorage(const IndexedStorage&) = delete;
-    IndexedStorage& operator=(const IndexedStorage&) = delete;
+    SlotMap(const SlotMap&) = delete;
+    SlotMap& operator=(const SlotMap&) = delete;
 
-    ~IndexedStorage()
+    ~SlotMap()
         { Reset(); }
 
     T& operator[](size_t index)
@@ -90,26 +90,28 @@ class IndexedStorage
         // Skip over free indices.
         for (size_t j = 0; j < freeSize_; ++j)
         {
+            size_t freeIndex = freeIndices_[j];
+
             for (; index < totalSize; ++index)
             {
-                if (j == freeIndex_)
+                if (index == freeIndex)
                 {
                     ++index;
                     break;
                 }
                 else
                 {
-                    data_[index].~T();
+                    reinterpret_cast<T&>(data_[index]).~T();
                 }
             }
         }
 
         // Rest
         for (; index < totalSize; ++index)
-            data_[index].~T();
+            reinterpret_cast<T&>(data_[index]).~T();
 
         size_ = 0;
-        freeList_ = 0;
+        freeSize_ = 0;
     }
 
     void Reset()
@@ -144,7 +146,7 @@ class IndexedStorage
         size_t  newCapacity = CalcNextCapacity();
         
         std::unique_ptr<StorageType[]> newData{ new StorageType[newCapacity] };
-        std::unique_ptr<size_t[]> newFreeList{ new size_t[newCapacity] };
+        std::unique_ptr<size_t[]> newFreeIndices{ new size_t[newCapacity] };
 
         // Move data to new storage
         for (size_t i = 0; i < capacity_; ++i)
@@ -157,7 +159,7 @@ class IndexedStorage
 
         // Use new storage
         data_           = std::move(newData);
-        freeIndices_    = std::move(newFreeList);
+        freeIndices_    = std::move(newFreeIndices);
         capacity_       = newCapacity;
     }
 
@@ -184,6 +186,6 @@ class IndexedStorage
     size_t  capacity_   = 0;
 };
 
-/****************************************/ REACT_IMPL_END /***************************************/
+/******************************************/ REACT_END /******************************************/
 
-#endif // REACT_COMMON_CONTAINERS_H_INCLUDED
\ No newline at end of file
+#endif // REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/syncpoint.h b/include/react/common/syncpoint.h
new file mode 100644
index 00000000..7ca5586b
--- /dev/null
+++ b/include/react/common/syncpoint.h
@@ -0,0 +1,195 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_COMMON_SYNCPOINT_H_INCLUDED
+#define REACT_COMMON_SYNCPOINT_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/defs.h"
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
+
+/*****************************************/ REACT_BEGIN /*****************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SyncPoint
+///////////////////////////////////////////////////////////////////////////////////////////////////
+class SyncPoint
+{
+private:
+    class Dependency;
+
+    class ISyncPointState
+    {
+    public:
+        virtual ~ISyncPointState() = default;
+
+        virtual void IncrementWaitCount() = 0;
+        
+        virtual void DecrementWaitCount() = 0;
+    };
+
+    class SyncPointState : public ISyncPointState
+    {
+    public:
+        virtual void IncrementWaitCount() override
+        {// mutex_
+            std::lock_guard<std::mutex> scopedLock(mtx_);
+            ++waitCount_;
+        }// ~mutex_
+
+        virtual void DecrementWaitCount() override
+        {// mutex_
+            std::lock_guard<std::mutex> scopedLock(mtx_);
+            --waitCount_;
+
+            if (waitCount_ == 0)
+                cv_.notify_all();
+        }// ~mutex_
+
+        void Wait()
+        {
+            std::unique_lock<std::mutex> lock(mtx_);
+            cv_.wait(lock, [this] { return waitCount_ == 0; });
+        }
+        
+        template <typename TRep, typename TPeriod>
+        bool WaitFor(const std::chrono::duration<TRep, TPeriod>& relTime)
+        {
+            std::unique_lock<std::mutex> lock(mtx_);
+            return cv_.wait_for(lock, relTime, [this] { return waitCount_ == 0; });
+        }
+
+        template <typename TRep, typename TPeriod>
+        bool WaitUntil(const std::chrono::duration<TRep, TPeriod>& relTime)
+        {
+            std::unique_lock<std::mutex> lock(mtx_);
+            return cv_.wait_until(lock, relTime, [this] { return waitCount_ == 0; });
+        }
+
+    private:
+        std::mutex              mtx_;
+        std::condition_variable cv_;
+
+        int waitCount_ = 0;
+    };
+
+    class SyncPointStateCollection : public ISyncPointState
+    {
+    private:
+        std::vector<Dependency>
+    };
+
+public:
+    SyncPoint() : state_( std::make_shared<SyncPointState>() )
+    { }
+
+    SyncPoint(const SyncPoint&) = default;
+
+    SyncPoint& operator=(const SyncPoint&) = default;
+
+    SyncPoint(SyncPoint&&) = default;
+
+    SyncPoint& operator=(SyncPoint&&) = default;
+
+    void Wait()
+    {
+        state_->Wait();
+    }
+
+    template <typename TRep, typename TPeriod>
+    bool WaitFor(const std::chrono::duration<TRep, TPeriod>& relTime)
+    {
+        return state_->WaitFor(relTime);
+    }
+
+    template <typename TRep, typename TPeriod>
+    bool WaitUntil(const std::chrono::duration<TRep, TPeriod>& relTime)
+    {
+        return state_->WaitUntil(relTime);
+    }
+
+    class Dependency
+    {
+    public:
+        Dependency() = default;
+
+        // Construct from single sync point.
+        explicit Dependency(const SyncPoint& sp) :
+            state_( sp.state_ )
+        {
+            state_->IncrementWaitCount();
+        }
+
+        // Construct from vector of other dependencies.
+        explicit Dependency(std::vector<Dependency>&& others) :
+            state_( sp.state_ )
+        {
+            state_->IncrementWaitCount();
+        }
+
+        Dependency(const Dependency& other) :
+            state_( other.state_ )
+        {
+            state_->IncrementWaitCount();
+        }
+
+        Dependency& operator=(const Dependency& other)
+        {
+            if (other.state_)
+                state_->IncrementWaitCount();
+
+            if (state_)
+                state_->DecrementWaitCount();
+
+            state_ = other.state_;
+        }
+
+        Dependency(Dependency&& other) :
+            state_( std::move(other.state_) )
+        { }
+
+        Dependency& operator=(Dependency&& other)
+        {
+            if (state_)
+                state_->DecrementWaitCount();
+
+            state_ = std::move(other.state_);
+        }
+
+        ~Dependency()
+        {
+            if (state_)
+                state_->DecrementWaitCount();
+        }
+
+        void Release()
+        {
+            if (state_)
+            {
+                state_->DecrementWaitCount();
+                state_.reset();
+            }
+        }
+
+        bool IsReleased() const
+            { return state_ == nullptr; }
+
+    private:
+        std::shared_ptr<ISyncPointState> state_;
+    };
+
+private:
+    std::shared_ptr<SyncPointState> state_;
+};
+
+/******************************************/ REACT_END /******************************************/
+
+#endif // REACT_COMMON_SYNCPOINT_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/utility.h b/include/react/common/utility.h
new file mode 100644
index 00000000..d1ce975d
--- /dev/null
+++ b/include/react/common/utility.h
@@ -0,0 +1,58 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_COMMON_UTIL_H_INCLUDED
+#define REACT_COMMON_UTIL_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/defs.h"
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Helper to enable calling a function on each element of an argument pack.
+/// We can't do f(args) ...; because ... expands with a comma.
+/// But we can do nop_func(f(args) ...);
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename... TArgs>
+inline void pass(TArgs&& ...) {}
+
+template <typename T>
+bool IsBitmaskSet(T flags, T mask)
+{
+    return (flags & mask) != (T)0;
+}
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
+// Expand args by wrapping them in a dummy function
+// Use comma operator to replace potential void return value with 0
+#define REACT_EXPAND_PACK(...) REACT_IMPL::pass((__VA_ARGS__ , 0) ...)
+
+#define REACT_DEFINE_BITMASK_OPERATORS(t) \
+    inline t operator|(t lhs, t rhs) \
+        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t operator&(t lhs, t rhs) \
+        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) & static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t operator^(t lhs, t rhs) \
+        { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t operator~(t rhs) \
+        { return static_cast<t>(~static_cast<std::underlying_type<t>::type>(rhs)); } \
+    inline t& operator|=(t& lhs, t rhs) \
+        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); return lhs; } \
+    inline t& operator&=(t& lhs, t rhs) \
+        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) & static_cast<std::underlying_type<t>::type>(rhs)); return lhs; } \
+    inline t& operator^=(t& lhs, t rhs) \
+        { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); return lhs; }
+
+// Bitmask helper
+
+#endif // REACT_COMMON_UTIL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/Defs.h b/include/react/detail/Defs.h
index 6bdda2e0..d1509c8c 100644
--- a/include/react/detail/Defs.h
+++ b/include/react/detail/Defs.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,6 @@
 
 #pragma once
 
-#include <cassert>
 #include <cstddef>
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -21,15 +20,13 @@
 #define REACT_IMPL_END      REACT_END       }
 #define REACT_IMPL          REACT           ::impl
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
+/*****************************************/ REACT_BEGIN /*****************************************/
 
 // Type aliases
 using uint = unsigned int;
 using uchar = unsigned char;
 using std::size_t;
 
-struct CtorTag { };
-
-/****************************************/ REACT_IMPL_END /***************************************/
+/******************************************/ REACT_END /******************************************/
 
 #endif // REACT_DETAIL_DEFS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/ReactiveInput.h b/include/react/detail/ReactiveInput.h
deleted file mode 100644
index d156b9fb..00000000
--- a/include/react/detail/ReactiveInput.h
+++ /dev/null
@@ -1,983 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#if 0
-
-#ifndef REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
-#define REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <atomic>
-#include <condition_variable>
-#include <deque>
-#include <functional>
-#include <limits>
-#include <memory>
-#include <mutex>
-#include <utility>
-#include <type_traits>
-#include <vector>
-
-#include "tbb/task.h"
-#include "tbb/concurrent_queue.h"
-#include "tbb/enumerable_thread_specific.h"
-#include "tbb/queuing_mutex.h"
-
-#include "IReactiveEngine.h"
-#include "ObserverBase.h"
-#include "react/common/Concurrency.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class IObserver;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Common types & constants
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-enum ETransactionFlags
-{
-    allow_merging    = 1 << 0
-};
-
-using TransactionFlagsT = std::underlying_type<ETransactionFlags>::type;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EInputMode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum EInputMode
-{
-    consecutive_input,
-    concurrent_input
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IContinuationTarget
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IContinuationTarget
-{
-    virtual void AsyncContinuation(TransactionFlagsT, const WaitingStatePtrT&,
-                                   TransactionFuncT&&) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ThreadLocalInputState
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename = void>
-struct ThreadLocalInputState
-{
-    static REACT_TLS bool   IsTransactionActive;
-};
-
-template <typename T>
-REACT_TLS bool ThreadLocalInputState<T>::IsTransactionActive(false);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ContinuationManager
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Interface
-template <EPropagationMode>
-class ContinuationManager
-{
-public:
-    void StoreContinuation(IContinuationTarget& target, TransactionFlagsT flags,
-                           TransactionFuncT&& cont);
-
-    bool HasContinuations() const;
-    void StartContinuations(const WaitingStatePtrT& waitingStatePtr);
-
-    void QueueObserverForDetach(IObserver& obs);
-
-    template <typename D>
-    void DetachQueuedObservers();
-};
-
-// Non thread-safe implementation
-template <>
-class ContinuationManager<sequential_propagation>
-{
-    struct Data_
-    {
-        Data_(IContinuationTarget* target, TransactionFlagsT flags, TransactionFuncT&& func) :
-            Target( target ),
-            Flags( flags ),
-            Func( func )
-        {}
-
-        IContinuationTarget*    Target;
-        TransactionFlagsT       Flags;
-        TransactionFuncT        Func;
-    };
-
-    using DataVectT = std::vector<Data_>;
-    using ObsVectT  = std::vector<IObserver*>;
-
-public:
-    void StoreContinuation(IContinuationTarget& target, TransactionFlagsT flags,
-                           TransactionFuncT&& cont)
-    {
-        storedContinuations_.emplace_back(&target, flags, std::move(cont));
-    }
-
-    bool HasContinuations() const
-    {
-        return !storedContinuations_.empty();
-    }
-
-    void StartContinuations(const WaitingStatePtrT& waitingStatePtr)
-    {
-        for (auto& t : storedContinuations_)
-            t.Target->AsyncContinuation(t.Flags, waitingStatePtr, std::move(t.Func));
-
-        storedContinuations_.clear();
-    }
-
-    // Todo: Move this somewhere else
-    void QueueObserverForDetach(IObserver& obs)
-    {
-        detachedObservers_.push_back(&obs);
-    }
-
-    template <typename D>
-    void DetachQueuedObservers()
-    {
-        for (auto* o : detachedObservers_)
-            o->UnregisterSelf();
-        detachedObservers_.clear();
-    }
-
-private:
-    DataVectT   storedContinuations_;
-    ObsVectT    detachedObservers_;
-};
-
-// Thread-safe implementation
-template <>
-class ContinuationManager<parallel_propagation>
-{
-    struct Data_
-    {
-        Data_(IContinuationTarget* target, TransactionFlagsT flags, TransactionFuncT&& func) :
-            Target( target ),
-            Flags( flags ),
-            Func( func )
-        {}
-
-        IContinuationTarget*    Target;
-        TransactionFlagsT       Flags;
-        TransactionFuncT        Func;
-    };
-
-    using DataVecT  = std::vector<Data_>;
-    using ObsVectT  = std::vector<IObserver*>;
-
-public:
-    void StoreContinuation(IContinuationTarget& target, TransactionFlagsT flags,
-                           TransactionFuncT&& cont)
-    {
-        storedContinuations_.local().emplace_back(&target, flags, std::move(cont));
-        ++contCount_;
-    }
-
-    bool HasContinuations() const
-    {
-        return contCount_ != 0;
-    }
-
-    void StartContinuations(const WaitingStatePtrT& waitingStatePtr)
-    {
-        for (auto& v : storedContinuations_)
-            for (auto& t : v)
-                t.Target->AsyncContinuation(t.Flags, waitingStatePtr, std::move(t.Func));
-
-        storedContinuations_.clear();
-        contCount_ = 0;
-    }
-
-    void QueueObserverForDetach(IObserver& obs)
-    {
-        detachedObservers_.local().push_back(&obs);
-    }
-
-    template <typename D>
-    void DetachQueuedObservers()
-    {
-        for (auto& v : detachedObservers_)
-        {
-            for (auto* o : v)
-                o->UnregisterSelf();
-            v.clear();
-        }
-    }
-
-private:
-    tbb::enumerable_thread_specific<DataVecT>   storedContinuations_;
-    tbb::enumerable_thread_specific<ObsVectT>   detachedObservers_;
-
-    size_t contCount_ = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TransactionQueue
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Interface
-template <EInputMode>
-class TransactionQueue
-{
-public:
-    class QueueEntry
-    {
-    public:
-        explicit QueueEntry(TransactionFlagsT flags);
-
-        void RunMergedInputs();
-
-        size_t  GetWaitingStatePtrCount() const;
-        void    MoveWaitingStatePtrs(std::vector<WaitingStatePtrT>& out);
-
-        void Release();
-
-        bool IsAsync() const;
-    };
-
-    template <typename F>
-    bool TryMergeSync(F&& inputFunc);
-
-    template <typename F>
-    bool TryMergeAsync(F&& inputFunc, WaitingStatePtrT&& waitingStatePtr);
-
-    void EnterQueue(QueueEntry& turn);
-    void ExitQueue(QueueEntry& turn);
-};
-
-// Non thread-safe implementation
-template <>
-class TransactionQueue<consecutive_input>
-{
-public:
-    class QueueEntry
-    {
-    public:
-        explicit QueueEntry(TransactionFlagsT flags) {}
-
-        void RunMergedInputs()  {}
-
-        size_t  GetWaitingStatePtrCount() const    { return 0; }
-        void    MoveWaitingStatePtrs(std::vector<WaitingStatePtrT>& out)  {}
-
-        void Release()  {}
-
-        bool IsAsync() const { return false; }
-    };
-
-    template <typename F>
-    bool TryMergeSync(F&& inputFunc) { return false; }
-
-    template <typename F>
-    bool TryMergeAsync(F&& inputFunc, WaitingStatePtrT&& waitingStatePtr) { return false; }
-
-    void EnterQueue(QueueEntry& turn)   {}
-    void ExitQueue(QueueEntry& turn)    {}
-};
-
-// Thread-safe implementation
-template <>
-class TransactionQueue<concurrent_input>
-{
-public:
-    class QueueEntry
-    {
-    public:
-        explicit QueueEntry(TransactionFlagsT flags) :
-            isMergeable_( (flags & allow_merging) != 0 )
-        {}
-
-        void Append(QueueEntry& tr)
-        {
-            successor_ = &tr;
-            tr.waitingState_.IncWaitCount();
-            ++waitingStatePtrCount_;
-        }
-
-        void WaitForUnblock()
-        {
-            waitingState_.Wait();
-        }
-
-        void RunMergedInputs() const
-        {
-            for (const auto& e : merged_)
-                e.InputFunc();
-        }
-
-        size_t GetWaitingStatePtrCount() const
-        {
-            return waitingStatePtrCount_;
-        }
-
-        void MoveWaitingStatePtrs(std::vector<WaitingStatePtrT>& out)
-        {
-            if (waitingStatePtrCount_ == 0)
-                return;
-
-            for (const auto& e : merged_)
-                if (e.WaitingStatePtr != nullptr)
-                    out.push_back(std::move(e.WaitingStatePtr));
-
-            if (successor_)
-            {
-                out.push_back(WaitingStatePtrT( &successor_->waitingState_ ));
-
-                // Ownership of successors waiting state has been transfered,
-                // we no longer need it
-                successor_ = nullptr;
-            }
-
-            waitingStatePtrCount_ = 0;
-        }
-
-        void Release()
-        {
-            if (waitingStatePtrCount_ == 0)
-                return;
-
-            // Release merged
-            for (const auto& e : merged_)
-                if (e.WaitingStatePtr != nullptr)
-                    e.WaitingStatePtr->DecWaitCount();
-
-            // Waiting state ptrs may point to stack of waiting threads.
-            // After decwaitcount, they may start running and terminate.
-            // Thus, clear merged ASAP because it now contains invalid ptrs.
-            merged_.clear();
-
-            // Release next thread in queue
-            if (successor_)
-                successor_->waitingState_.DecWaitCount();
-        }
-
-        template <typename F, typename P>
-        bool TryMerge(F&& inputFunc, P&& waitingStatePtr)
-        {
-            if (!isMergeable_)
-                return false;
-
-            // Only merge if target is still waiting
-            bool merged = waitingState_.RunIfWaiting([&] {
-                if (waitingStatePtr != nullptr)
-                {
-                    waitingStatePtr->IncWaitCount();
-                    ++waitingStatePtrCount_;
-                }
-
-                merged_.emplace_back(std::forward<F>(inputFunc), std::forward<P>(waitingStatePtr));
-            });
-
-            return merged;
-        }
-
-    private:
-        struct MergedData
-        {
-            template <typename F, typename P>
-            MergedData(F&& func, P&& waitingStatePtr) :
-                InputFunc( std::forward<F>(func) ),
-                WaitingStatePtr( std::forward<P>(waitingStatePtr) )
-            {}
-
-            std::function<void()>   InputFunc;
-            WaitingStatePtrT        WaitingStatePtr;
-        };
-
-        using MergedDataVectT = std::vector<MergedData>;
-
-        bool                isMergeable_;
-        QueueEntry*         successor_      = nullptr;
-        MergedDataVectT     merged_;
-        UniqueWaitingState  waitingState_;
-        size_t              waitingStatePtrCount_ = 0;
-    };
-
-    template <typename F>
-    bool TryMergeSync(F&& inputFunc)
-    {
-        bool merged = false;
-
-        UniqueWaitingState st;
-        WaitingStatePtrT p( &st );
-
-        {// seqMutex_
-            SeqMutexT::scoped_lock lock(seqMutex_);
-
-            if (tail_)
-                merged = tail_->TryMerge(std::forward<F>(inputFunc), p);
-        }// ~seqMutex_
-
-        if (merged)
-            p->Wait();
-
-        return merged;
-    }
-
-    template <typename F>
-    bool TryMergeAsync(F&& inputFunc, WaitingStatePtrT&& waitingStatePtr)
-    {
-        bool merged = false;
-
-        {// seqMutex_
-            SeqMutexT::scoped_lock lock(seqMutex_);
-
-            if (tail_)
-                merged = tail_->TryMerge(std::forward<F>(inputFunc), std::move(waitingStatePtr));
-        }// ~seqMutex_
-
-        return merged;
-    }
-
-    void EnterQueue(QueueEntry& tr)
-    {
-        {// seqMutex_
-            SeqMutexT::scoped_lock lock(seqMutex_);
-
-            if (tail_)
-                tail_->Append(tr);
-
-            tail_ = &tr;
-        }// ~seqMutex_
-
-        tr.WaitForUnblock();
-    }
-
-    void ExitQueue(QueueEntry& tr)
-    {
-        {// seqMutex_
-            SeqMutexT::scoped_lock lock(seqMutex_);
-
-            if (tail_ == &tr)
-                tail_ = nullptr;
-        }// ~seqMutex_
-
-        tr.Release();
-    }
-
-private:
-    using SeqMutexT = tbb::queuing_mutex;
-
-    SeqMutexT       seqMutex_;
-    QueueEntry*     tail_       = nullptr;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AsyncWorker
-///////////////////////////////////////////////////////////////////////////////////////////////////
-struct AsyncItem
-{
-    TransactionFlagsT       Flags;
-    WaitingStatePtrT        WaitingStatePtr;
-    TransactionFuncT        Func;
-};
-
-// Interface
-template <typename D, EInputMode>
-class AsyncWorker
-{
-public:
-    AsyncWorker(InputManager<D>& mgr);
-
-    void PushItem(AsyncItem&& item);
-
-    void PopItem(AsyncItem& item);
-    bool TryPopItem(AsyncItem& item);
-
-    bool IncrementItemCount(size_t n);
-    bool DecrementItemCount(size_t n);
-
-    void Start();
-};
-
-// Disabled
-template <typename D>
-struct AsyncWorker<D, consecutive_input>
-{
-public:
-    AsyncWorker(InputManager<D>& mgr)
-    {}
-
-    void PushItem(AsyncItem&& item)     { assert(false); }
-
-    void PopItem(AsyncItem& item)       { assert(false); }
-    bool TryPopItem(AsyncItem& item)    { assert(false); return false; }
-
-    bool IncrementItemCount(size_t n)   { assert(false); return false; }
-    bool DecrementItemCount(size_t n)   { assert(false); return false; }
-
-    void Start()                        { assert(false); }
-};
-
-// Enabled
-template <typename D>
-struct AsyncWorker<D, concurrent_input>
-{
-    using DataT = tbb::concurrent_bounded_queue<AsyncItem>;
-
-    class WorkerTask : public tbb::task
-    {
-    public:
-        WorkerTask(InputManager<D>& mgr) :
-            mgr_( mgr )
-        {}
-
-        tbb::task* execute()
-        {
-            mgr_.processAsyncQueue();
-            return nullptr;
-        }
-
-    private:
-        InputManager<D>& mgr_;
-    };
-
-public:
-    AsyncWorker(InputManager<D>& mgr) :
-        mgr_( mgr )
-    {}
-
-    void PushItem(AsyncItem&& item)
-    {
-        data_.push(std::move(item));
-    }
-
-    void PopItem(AsyncItem& item)
-    {
-        data_.pop(item);
-    }
-
-    bool TryPopItem(AsyncItem& item)
-    {
-        return data_.try_pop(item);
-    }
-
-    bool IncrementItemCount(size_t n)
-    {
-        return count_.fetch_add(n, std::memory_order_relaxed) == 0;
-    }
-
-    bool DecrementItemCount(size_t n)
-    {
-        return count_.fetch_sub(n, std::memory_order_relaxed) == n;
-    }
-
-    void Start()
-    {
-        tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(mgr_));
-    }
-
-private:
-    DataT               data_;
-    std::atomic<size_t> count_{ 0 };
-
-    InputManager<D>&    mgr_;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// InputManager
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename D>
-class InputManager :
-    public IContinuationTarget
-{
-private:
-    // Select between thread-safe and non thread-safe implementations
-    using TransactionQueueT = TransactionQueue<D::Policy::input_mode>;
-    using QueueEntryT = typename TransactionQueueT::QueueEntry;
-
-    using ContinuationManagerT = ContinuationManager<D::Policy::propagation_mode>;
-    using AsyncWorkerT = AsyncWorker<D, D::Policy::input_mode>;
-
-    template <typename, EInputMode>
-    friend class AsyncWorker;
-
-public:
-    using TurnT = typename D::TurnT;
-    using Engine = typename D::Engine;
-
-    InputManager() :
-        asyncWorker_(*this)
-    {}
-
-    template <typename F>
-    void DoTransaction(TransactionFlagsT flags, F&& func)
-    {
-        // Attempt to add input to another turn.
-        // If successful, blocks until other turn is done and returns.
-        bool canMerge = (flags & allow_merging) != 0;
-        if (canMerge && transactionQueue_.TryMergeSync(std::forward<F>(func)))
-            return;
-
-        bool shouldPropagate = false;
-        
-        QueueEntryT tr( flags );
-
-        transactionQueue_.EnterQueue(tr);
-
-        // Phase 1 - Input admission
-        ThreadLocalInputState<>::IsTransactionActive = true;
-
-        TurnT turn( nextTurnId(), flags );
-        Engine::OnTurnAdmissionStart(turn);
-        func();
-        tr.RunMergedInputs();
-        Engine::OnTurnAdmissionEnd(turn);
-
-        ThreadLocalInputState<>::IsTransactionActive = false;
-
-        // Phase 2 - Apply input node changes
-        for (auto* p : changedInputs_)
-            if (p->ApplyInput(&turn))
-                shouldPropagate = true;
-        changedInputs_.clear();
-
-        // Phase 3 - Propagate changes
-        if (shouldPropagate)
-            Engine::Propagate(turn);
-
-        finalizeSyncTransaction(tr);
-    }
-
-    template <typename F>
-    void AsyncTransaction(TransactionFlagsT flags, const WaitingStatePtrT& waitingStatePtr, F&& func)
-    {
-        if (waitingStatePtr != nullptr)
-            waitingStatePtr->IncWaitCount();
-
-        asyncWorker_.PushItem(AsyncItem{ flags, waitingStatePtr, std::forward<F>(func) });
-
-        if (asyncWorker_.IncrementItemCount(1))
-            asyncWorker_.Start();
-    }
-
-    template <typename R, typename V>
-    void AddInput(R& r, V&& v)
-    {
-        if (ThreadLocalInputState<>::IsTransactionActive)
-        {
-            addTransactionInput(r, std::forward<V>(v));
-        }
-        else
-        {
-            addSimpleInput(r, std::forward<V>(v));
-        }
-    }
-
-    template <typename R, typename F>
-    void ModifyInput(R& r, const F& func)
-    {
-        if (ThreadLocalInputState<>::IsTransactionActive)
-        {
-            modifyTransactionInput(r, func);
-        }
-        else
-        {
-            modifySimpleInput(r, func);
-        }
-    }
-
-    //IContinuationTarget        
-    virtual void AsyncContinuation(TransactionFlagsT flags, const WaitingStatePtrT& waitingStatePtr, TransactionFuncT&& cont) override
-    {
-        AsyncTransaction(flags, waitingStatePtr, std::move(cont));
-    }
-    //~IContinuationTarget
-
-    void StoreContinuation(IContinuationTarget& target, TransactionFlagsT flags,
-                           TransactionFuncT&& cont)
-    {
-        continuationManager_.StoreContinuation(target, flags, std::move(cont));
-    }
-
-    void QueueObserverForDetach(IObserver& obs)
-    {
-        continuationManager_.QueueObserverForDetach(obs);
-    }
-
-private:
-    TurnIdT nextTurnId()
-    {
-        auto curId = nextTurnId_.fetch_add(1, std::memory_order_relaxed);
-
-        if (curId == (std::numeric_limits<int>::max)())
-            nextTurnId_.fetch_sub((std::numeric_limits<int>::max)());
-
-        return curId;
-    }
-
-    // Create a turn with a single input
-    template <typename R, typename V>
-    void addSimpleInput(R& r, V&& v)
-    {
-        QueueEntryT tr( 0 );
-
-        transactionQueue_.EnterQueue(tr);
-
-        TurnT turn( nextTurnId(), 0 );
-        Engine::OnTurnAdmissionStart(turn);
-        r.AddInput(std::forward<V>(v));
-        tr.RunMergedInputs();
-        Engine::OnTurnAdmissionEnd(turn);
-
-        if (r.ApplyInput(&turn))
-            Engine::Propagate(turn);
-
-        finalizeSyncTransaction(tr);
-    }
-
-    template <typename R, typename F>
-    void modifySimpleInput(R& r, const F& func)
-    {
-        QueueEntryT tr( 0 );
-
-        transactionQueue_.EnterQueue(tr);
-
-        TurnT turn( nextTurnId(), 0 );
-        Engine::OnTurnAdmissionStart(turn);
-        r.ModifyInput(func);
-        Engine::OnTurnAdmissionEnd(turn);
-
-        // Return value, will always be true
-        r.ApplyInput(&turn);
-
-        Engine::Propagate(turn);
-
-        finalizeSyncTransaction(tr);
-    }
-
-    void finalizeSyncTransaction(QueueEntryT& tr)
-    {
-        continuationManager_.template DetachQueuedObservers<D>();
-
-        if (continuationManager_.HasContinuations())
-        {
-            UniqueWaitingState st;
-            WaitingStatePtrT p( &st );
-
-            continuationManager_.StartContinuations(p);
-
-            transactionQueue_.ExitQueue(tr);
-
-            p->Wait();
-        }
-        else
-        {
-            transactionQueue_.ExitQueue(tr);
-        }
-    }
-
-    // This input is part of an active transaction
-    template <typename R, typename V>
-    void addTransactionInput(R& r, V&& v)
-    {
-        r.AddInput(std::forward<V>(v));
-        changedInputs_.push_back(&r);
-    }
-
-    template <typename R, typename F>
-    void modifyTransactionInput(R& r, const F& func)
-    {
-        r.ModifyInput(func);
-        changedInputs_.push_back(&r);
-    }
-
-    void processAsyncQueue()
-    {
-        AsyncItem   item;
-
-        std::vector<WaitingStatePtrT> waitingStatePtrs;
-
-        bool skipPop = false;
-
-        while (true)
-        {
-            size_t popCount = 0;
-
-            if (!skipPop)
-            {
-                // Blocks if queue is empty.
-                // This should never happen,
-                // and if (maybe due to some memory access internals), only briefly
-                asyncWorker_.PopItem(item);
-                popCount++;
-            }
-            else
-            {
-                skipPop = false;
-            }
-
-            // First try to merge to an existing synchronous item in the queue
-            bool canMerge = (item.Flags & allow_merging) != 0;
-            if (canMerge && transactionQueue_.TryMergeAsync(
-                    std::move(item.Func),
-                    std::move(item.WaitingStatePtr)))
-                continue;
-
-            bool shouldPropagate = false;
-            
-            QueueEntryT tr( item.Flags );
-
-            // Blocks until turn is at the front of the queue
-            transactionQueue_.EnterQueue(tr);
-
-            TurnT turn( nextTurnId(), item.Flags );
-
-            // Phase 1 - Input admission
-            ThreadLocalInputState<>::IsTransactionActive = true;
-
-            Engine::OnTurnAdmissionStart(turn);
-
-            // Input of current item
-            item.Func();
-
-            // Merged sync inputs that arrived while this item was queued
-            tr.RunMergedInputs(); 
-
-            // Save data, item might be re-used for next input
-            if (item.WaitingStatePtr != nullptr)
-                waitingStatePtrs.push_back(std::move(item.WaitingStatePtr));
-
-            // If the current item supports merging, try to add more mergeable inputs
-            // to this turn
-            if (canMerge)
-            {
-                uint extraCount = 0;
-                // Todo: Make configurable
-                while (extraCount < 1024 && asyncWorker_.TryPopItem(item))
-                {
-                    ++popCount;
-
-                    bool canMergeNext = (item.Flags & allow_merging) != 0;
-                    if (canMergeNext)
-                    {
-                        item.Func();
-
-                        if (item.WaitingStatePtr != nullptr)
-                            waitingStatePtrs.push_back(std::move(item.WaitingStatePtr));
-
-                        ++extraCount;
-                    }
-                    else
-                    {
-                        // We already popped an item we could not merge
-                        // Process it in the next iteration
-                        skipPop = true;
-
-                        // Break at first item that cannot be merged.
-                        // We only allow merging of continuous ranges.
-                        break;
-                    }
-                }
-            }
-
-            Engine::OnTurnAdmissionEnd(turn);
-
-            ThreadLocalInputState<>::IsTransactionActive = false;
-
-            // Phase 2 - Apply input node changes
-            for (auto* p : changedInputs_)
-                if (p->ApplyInput(&turn))
-                    shouldPropagate = true;
-            changedInputs_.clear();
-
-            // Phase 3 - Propagate changes
-            if (shouldPropagate)
-                Engine::Propagate(turn);
-
-            continuationManager_.template DetachQueuedObservers<D>();
-
-            // Has continuations? If so, status ptrs have to be passed on to
-            // continuation transactions
-            if (continuationManager_.HasContinuations())
-            {
-                // Merge all waiting state ptrs for this transaction into a single vector
-                tr.MoveWaitingStatePtrs(waitingStatePtrs);
-
-                // More than 1 waiting state -> create collection from vector
-                if (waitingStatePtrs.size() > 1)
-                {
-                    WaitingStatePtrT p
-                    (
-                        SharedWaitingStateCollection::Create(std::move(waitingStatePtrs))
-                    );
-
-                    continuationManager_.StartContinuations(p);
-
-                    transactionQueue_.ExitQueue(tr);
-                    p->DecWaitCount();
-                }
-                // Exactly one status ptr -> pass it on directly
-                else if (waitingStatePtrs.size() == 1)
-                {
-                    WaitingStatePtrT p( std::move(waitingStatePtrs[0]) );
-
-                    continuationManager_.StartContinuations(p);
-
-                    transactionQueue_.ExitQueue(tr);
-                    p->DecWaitCount();
-                }
-                // No status ptrs
-                else
-                {
-                    continuationManager_.StartContinuations(nullptr);
-                }
-            }
-            else
-            {
-                transactionQueue_.ExitQueue(tr);
-
-                for (auto& p : waitingStatePtrs)
-                    p->DecWaitCount();
-            }
-
-            waitingStatePtrs.clear();
-
-            // Stop this task if the number of items has just been decremented zero.
-            // A new task will be started by the thread that increments the item count from zero.
-            if (asyncWorker_.DecrementItemCount(popCount))
-                break;
-        }
-    }
-
-    TransactionQueueT       transactionQueue_;
-    ContinuationManagerT    continuationManager_;
-    AsyncWorkerT            asyncWorker_;
-
-    std::atomic<TurnIdT>    nextTurnId_{ 0 };
-
-    std::vector<IInputNode*>    changedInputs_;
-};
-
-template <typename D>
-class DomainSpecificInputManager
-{
-public:
-    DomainSpecificInputManager() = delete;
-
-    static InputManager<D>& Instance()
-    {
-        static InputManager<D> instance;
-        return instance;
-    }
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_REACTIVEINPUT_H_INCLUDED
-
-#endif
\ No newline at end of file
diff --git a/include/react/detail/graph/AlgorithmNodes.h b/include/react/detail/algorithm_nodes.h
similarity index 68%
rename from include/react/detail/graph/AlgorithmNodes.h
rename to include/react/detail/algorithm_nodes.h
index fdb925e1..94cdde7e 100644
--- a/include/react/detail/graph/AlgorithmNodes.h
+++ b/include/react/detail/algorithm_nodes.h
@@ -1,83 +1,24 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DETAIL_GRAPH_ALGORITHMNODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_ALGORITHMNODES_H_INCLUDED
+#ifndef REACT_DETAIL_ALGORITHM_NODES_H_INCLUDED
+#define REACT_DETAIL_ALGORITHM_NODES_H_INCLUDED
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <memory>
 #include <utility>
 
-#include "EventNodes.h"
-#include "SignalNodes.h"
+#include "event_nodes.h"
+#include "signal_nodes.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AddIterateRangeWrapper
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E, typename S, typename F, typename ... TArgs>
-struct AddIterateRangeWrapper
-{
-    AddIterateRangeWrapper(const AddIterateRangeWrapper& other) = default;
-
-    AddIterateRangeWrapper(AddIterateRangeWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template
-    <
-        typename FIn,
-        class = typename DisableIfSame<FIn,AddIterateRangeWrapper>::type
-    >
-    explicit AddIterateRangeWrapper(FIn&& func) :
-        MyFunc( std::forward<FIn>(func) )
-    {}
-
-    S operator()(EventRange<E> range, S value, const TArgs& ... args)
-    {
-        for (const auto& e : range)
-            value = MyFunc(e, value, args ...);
-
-        return value;
-    }
-
-    F MyFunc;
-};
-
-template <typename E, typename S, typename F, typename ... TArgs>
-struct AddIterateByRefRangeWrapper
-{
-    AddIterateByRefRangeWrapper(const AddIterateByRefRangeWrapper& other) = default;
-
-    AddIterateByRefRangeWrapper(AddIterateByRefRangeWrapper&& other) :
-        MyFunc( std::move(other.MyFunc) )
-    {}
-
-    template
-    <
-        typename FIn,
-        class = typename DisableIfSame<FIn,AddIterateByRefRangeWrapper>::type
-    >
-    explicit AddIterateByRefRangeWrapper(FIn&& func) :
-        MyFunc( std::forward<FIn>(func) )
-    {}
-
-    void operator()(EventRange<E> range, S& valueRef, const TArgs& ... args)
-    {
-        for (const auto& e : range)
-            MyFunc(e, valueRef, args ...);
-    }
-
-    F MyFunc;
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// IterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -101,12 +42,10 @@ class IterateNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         S newValue = func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value());
 
-        GetInternals(evnt_).DecrementPendingSuccessorCount();
-
         if (! (newValue == this->Value()))
         {
             this->Value() = std::move(newValue);
@@ -118,12 +57,6 @@ class IterateNode : public SignalNode<S>
         }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "Iterate"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
 private:
     F           func_;
     Event<E>    evnt_;
@@ -152,22 +85,14 @@ class IterateByRefNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value());
 
-        GetInternals(evnt_).DecrementPendingSuccessorCount();
-
         // Always assume change
         return UpdateResult::changed;
     }
 
-    virtual const char* GetNodeType() const override
-        { return "IterateByRefNode"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
 protected:
     F           func_;
     Event<E>    evnt_;
@@ -194,26 +119,24 @@ class SyncedIterateNode : public SignalNode<S>
 
     ~SyncedIterateNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        std::apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
-        S newValue = apply(
+        S newValue = std::apply(
             [this] (const auto& ... syncs)
             {
                 return func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(syncs).Value() ...);
             },
             syncHolder_);
 
-        GetInternals(evnt_).DecrementPendingSuccessorCount();
-
         if (! (newValue == this->Value()))
         {
             this->Value() = std::move(newValue);
@@ -225,12 +148,6 @@ class SyncedIterateNode : public SignalNode<S>
         }   
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SyncedIterate"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1 + sizeof...(TSyncs); }
-
 private:
     F           func_;
     Event<E>    evnt_;
@@ -259,35 +176,27 @@ class SyncedIterateByRefNode : public SignalNode<S>
 
     ~SyncedIterateByRefNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        std::apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
-        apply(
+        std::apply(
             [this] (const auto& ... args)
             {
                 func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(args).Value() ...);
             },
             syncHolder_);
 
-        GetInternals(evnt_).DecrementPendingSuccessorCount();
-
         return UpdateResult::changed;
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SyncedIterateByRef"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1 + sizeof...(TSyncs); }
-
 private:
     F           func_;
     Event<E>    events_;
@@ -317,10 +226,7 @@ class HoldNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "HoldNode"; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         bool changed = false;
 
@@ -333,8 +239,6 @@ class HoldNode : public SignalNode<S>
                 changed = true;
                 this->Value() = newValue;
             }
-
-            GetInternals(evnt_).DecrementPendingSuccessorCount();
         }
 
         if (changed)
@@ -343,9 +247,6 @@ class HoldNode : public SignalNode<S>
             return UpdateResult::unchanged;
     }
 
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
 private:
     Event<S>  evnt_;
 };
@@ -374,7 +275,7 @@ class SnapshotNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         bool changed = false;
         
@@ -387,8 +288,6 @@ class SnapshotNode : public SignalNode<S>
                 changed = true;
                 this->Value() = newValue;
             }
-
-            GetInternals(trigger_).DecrementPendingSuccessorCount();
         }
 
         if (changed)
@@ -397,12 +296,6 @@ class SnapshotNode : public SignalNode<S>
             return UpdateResult::unchanged;
     }
 
-    virtual const char* GetNodeType() const override
-        { return "Snapshot"; }
-
-    virtual int GetDependencyCount() const override
-        { return 2; }
-
 private:
     Signal<S>   target_;
     Event<E>    trigger_;
@@ -429,21 +322,13 @@ class MonitorNode : public EventStreamNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         this->Events().push_back(GetInternals(target_).Value());
 
-        this->SetPendingSuccessorCount(successorCount);
-
         return UpdateResult::changed;
     }
 
-    virtual const char* GetNodeType() const override
-        { return "Monitor"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
 private:
     Signal<S>    target_;
 };
@@ -472,16 +357,13 @@ class PulseNode : public EventStreamNode<S>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         for (size_t i = 0; i < GetInternals(trigger_).Events().size(); i++)
             this->Events().push_back(GetInternals(target_).Value());
 
-        GetInternals(trigger_).DecrementPendingSuccessorCount();
-
         if (! this->Events().empty())
         {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
         }
         else
@@ -490,12 +372,6 @@ class PulseNode : public EventStreamNode<S>
         }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "Pulse"; }
-
-    virtual int GetDependencyCount() const override
-        { return 2; }
-
 private:
     Signal<S>   target_;
     Event<E>    trigger_;
@@ -503,4 +379,4 @@ class PulseNode : public EventStreamNode<S>
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_GRAPH_ALGORITHMNODES_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_ALGORITHM_NODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/EventNodes.h b/include/react/detail/event_nodes.h
similarity index 66%
rename from include/react/detail/graph/EventNodes.h
rename to include/react/detail/event_nodes.h
index e216b4b5..1a2e1cdf 100644
--- a/include/react/detail/graph/EventNodes.h
+++ b/include/react/detail/event_nodes.h
@@ -1,15 +1,15 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DETAIL_GRAPH_EVENTNODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_EVENTNODES_H_INCLUDED
+#ifndef REACT_DETAIL_EVENT_NODES_H_INCLUDED
+#define REACT_DETAIL_EVENT_NODES_H_INCLUDED
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <atomic>
 #include <deque>
@@ -19,7 +19,7 @@
 
 //#include "tbb/spin_mutex.h"
 
-#include "GraphBase.h"
+#include "node_base.h"
 #include "react/common/Types.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
@@ -28,39 +28,10 @@
 /// Iterators for event processing
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E = Token>
-class EventRange
-{
-public:
-    using const_iterator = typename std::vector<E>::const_iterator;
-    using size_type = typename std::vector<E>::size_type;
-
-    EventRange() = delete;
-
-    EventRange(const EventRange&) = default;
-    EventRange& operator=(const EventRange&) = default;
-
-    explicit EventRange(const std::vector<E>& data) :
-        data_( data )
-        { }
-
-    const_iterator begin() const
-        { return data_.begin(); }
-
-    const_iterator end() const
-        { return data_.end(); }
-
-    size_type GetSize() const
-        { return data_.size(); }
-
-    bool IsEmpty() const
-        { return data_.empty(); }
-
-private:
-    const std::vector<E>&    data_;
-};
+using EventValueList = std::vector<E>;
 
 template <typename E>
-using EventSink = std::back_insert_iterator<std::vector<E>>;
+using EventValueSink = std::back_insert_iterator<std::vector<E>>;
 
 /******************************************/ REACT_END /******************************************/
 
@@ -79,8 +50,6 @@ template <typename E>
 class EventStreamNode : public NodeBase
 {
 public:
-    using StorageType = std::vector<E>;
-
     EventStreamNode(EventStreamNode&&) = default;
     EventStreamNode& operator=(EventStreamNode&&) = default;
 
@@ -88,53 +57,27 @@ class EventStreamNode : public NodeBase
     EventStreamNode& operator=(const EventStreamNode&) = delete;
 
     explicit EventStreamNode(const Group& group) :
-        NodeBase( group )
-        { }
+        EventStreamNode::NodeBase( group )
+    { }
 
-    StorageType& Events()
+    EventValueList<E>& Events()
         { return events_; }
 
-    const StorageType& Events() const
+    const EventValueList<E>& Events() const
         { return events_; }
 
-
-    void SetPendingSuccessorCount(size_t count)
-    {
-        if (count == 0)
-        {
-            // If there are no successors, buffer is cleared immediately.
-            events_.clear();
-        }
-        else
-        {
-            // Otherwise, the last finished successor clears it.
-            pendingSuccessorCount_ = count;
-        }
-    }
-
-    void DecrementPendingSuccessorCount()
-    {
-        // Not all predecessors of a node might be visited during a turn.
-        // In this case, the count is zero and the call to this function should be ignored.
-        if (pendingSuccessorCount_ == 0)
-            return;
-
-        // Last successor to arrive clears the buffer.
-        if (pendingSuccessorCount_-- == 1)
-            events_.clear();
-    }
+    virtual void Clear() noexcept override
+        { events_.clear(); }
 
 private:
-    StorageType events_;
-    
-    std::atomic<size_t> pendingSuccessorCount_ = 0;
+    EventValueList<E> events_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventSourceNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class EventSourceNode : public EventStreamNode<T>
+template <typename E>
+class EventSourceNode : public EventStreamNode<E>
 {
 public:
     EventSourceNode(const Group& group) :
@@ -148,23 +91,12 @@ class EventSourceNode : public EventStreamNode<T>
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "EventSource"; }
-
-    virtual int GetDependencyCount() const override
-        { return 0; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         if (! this->Events().empty())
-        {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
     template <typename U>
@@ -175,13 +107,13 @@ class EventSourceNode : public EventStreamNode<T>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventMergeNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TOut, typename ... TIns>
-class EventMergeNode : public EventStreamNode<TOut>
+template <typename E, typename ... TInputs>
+class EventMergeNode : public EventStreamNode<E>
 {
 public:
-    EventMergeNode(const Group& group, const Event<TIns>& ... deps) :
+    EventMergeNode(const Group& group, const Event<TInputs>& ... deps) :
         EventMergeNode::EventStreamNode( group ),
-        depHolder_( deps ... )
+        inputs_( deps ... )
     {
         this->RegisterMe();
         REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
@@ -189,43 +121,31 @@ class EventMergeNode : public EventStreamNode<TOut>
 
     ~EventMergeNode()
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
+        std::apply([this] (const auto& ... deps)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        apply([this] (auto& ... deps) { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
+        std::apply([this] (auto& ... deps)
+            { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
         if (! this->Events().empty())
-        {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "EventMerge"; }
-
-    virtual int GetDependencyCount() const override
-        { return sizeof...(TIns); }
-
 private:
     template <typename U>
-    void MergeFromDep(Event<U>& dep)
+    void MergeFromInput(Event<U>& dep)
     {
-        auto& depInternals = GetInternals(dep);
-
+        EventInternals& depInternals = GetInternals(dep);
         this->Events().insert(this->Events().end(), depInternals.Events().begin(), depInternals.Events().end());
-        
-        depInternals.DecrementPendingSuccessorCount();
     }
 
-    std::tuple<Event<TIns> ...> depHolder_;
+    std::tuple<Event<TInputs> ...> inputs_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -253,31 +173,18 @@ class EventSlotNode : public EventStreamNode<E>
         GetGraphPtr()->UnregisterNode(inputNodeId_);
     }
 
-    virtual const char* GetNodeType() const override
-        { return "EventSlot"; }
-
-    virtual int GetDependencyCount() const override
-        { return 2; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         for (auto& e : inputs_)
         {
             const auto& events = GetInternals(e).Events();
             this->Events().insert(this->Events().end(), events.begin(), events.end());
-
-            GetInternals(e).DecrementPendingSuccessorCount();
         }
 
         if (! this->Events().empty())
-        {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
     void AddInput(const Event<E>& input)
@@ -312,15 +219,9 @@ class EventSlotNode : public EventStreamNode<E>
         { return inputNodeId_; }
 
 private:        
-    struct VirtualInputNode : public IReactiveNode
+    struct VirtualInputNode : public IReactNode
     {
-        virtual const char* GetNodeType() const override
-            { return "EventSlotInput"; }
-
-        virtual int GetDependencyCount() const override
-            { return 0; }
-
-        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+        virtual UpdateResult Update(TurnId turnId) noexcept override
             { return UpdateResult::changed; }
     };
 
@@ -353,29 +254,16 @@ class EventProcessingNode : public EventStreamNode<TOut>
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         func_(EventRange<TIn>( GetInternals(dep_).Events() ), std::back_inserter(this->Events()));
 
-        GetInternals(dep_).DecrementPendingSuccessorCount();
-
         if (! this->Events().empty())
-        {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "EventProcessing"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
 private:
     F func_;
 
@@ -403,43 +291,30 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 
     ~SyncedEventProcessingNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        std::apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
         this->DetachFromMe(dep_->GetNodeId());
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (dep_->Events().empty())
             return UpdateResult::unchanged;
 
-        apply(
+        std::apply(
             [this] (const auto& ... syncs)
             {
                 func_(EventRange<TIn>( this->dep_->Events() ), std::back_inserter(this->Events()), syncs->Value() ...);
             },
             syncHolder_);
 
-        dep_->DecrementPendingSuccessorCount();
-
         if (! this->Events().empty())
-        {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SyncedEventProcessing"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1 + sizeof...(TSyncs); }
-
 private:
     F func_;
 
@@ -465,21 +340,21 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 
     ~EventJoinNode()
     {
-        apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
+        std::apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
         this->UnregisterMe();
     }
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Move events into buffers.
-        apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
+        std::apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
 
         while (true)
         {
             bool isReady = true;
 
             // All slots ready?
-            apply(
+            std::apply(
                 [this, &isReady] (Slot<Ts>& ... slots)
                 {
                     // Todo: combine return values instead
@@ -491,7 +366,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
                 break;
 
             // Pop values from buffers and emit tuple.
-            apply(
+            std::apply(
                 [this] (Slot<Ts>& ... slots)
                 {
                     this->Events().emplace_back(slots.buffer.front() ...);
@@ -511,12 +386,6 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
         }
     }
 
-    virtual const char* GetNodeType() const override
-        { return "EventJoin"; }
-
-    virtual int GetDependencyCount() const override
-        { return sizeof...(Ts); }
-
 private:
     template <typename U>
     struct Slot
@@ -571,23 +440,14 @@ class EventLinkNode : public EventStreamNode<E>
     void SetWeakSelfPtr(const std::weak_ptr<EventLinkNode>& self)
         { linkOutput_.parent = self; }
 
-    virtual const char* GetNodeType() const override
-        { return "EventLink"; }
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+        { return UpdateResult::changed; }
 
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
-    {
-        this->SetPendingSuccessorCount(successorCount);
-        return UpdateResult::changed;
-    }
-
-    void SetEvents(EventLinkNode::EventStreamNode::StorageType&& events)
+    void SetEvents(EventValueList<E>&& events)
         { this->Events() = std::move(events); }
 
 private:
-    struct VirtualOutputNode : public ILinkOutputNode
+    struct VirtualOutputNode : public IReactNode
     {
         VirtualOutputNode(const Event<E>& depIn) :
             parent( ),
@@ -596,23 +456,17 @@ class EventLinkNode : public EventStreamNode<E>
         {
             auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
             nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-            srcGraphPtr->OnNodeAttach(nodeId, GetInternals(dep).GetNodeId());
+            srcGraphPtr->AttachNode(nodeId, GetInternals(dep).GetNodeId());
         }
 
         ~VirtualOutputNode()
         {
             auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
-            srcGraphPtr->OnNodeDetach(nodeId, GetInternals(dep).GetNodeId());
+            srcGraphPtr->DetachNode(nodeId, GetInternals(dep).GetNodeId());
             srcGraphPtr->UnregisterNode(nodeId);
         }
 
-        virtual const char* GetNodeType() const override
-            { return "EventLinkOutput"; }
-
-        virtual int GetDependencyCount() const override
-            { return 1; }
-
-        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+        virtual UpdateResult Update(TurnId turnId) noexcept override
             { return UpdateResult::changed; }
 
         virtual void CollectOutput(LinkOutputMap& output) override
@@ -645,6 +499,42 @@ class EventLinkNode : public EventStreamNode<E>
     VirtualOutputNode linkOutput_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// EventInternals
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename E>
+class EventInternals
+{
+public:
+    EventInternals(const EventInternals&) = default;
+    EventInternals& operator=(const EventInternals&) = default;
+
+    EventInternals(EventInternals&&) = default;
+    EventInternals& operator=(EventInternals&&) = default;
+
+    explicit EventInternals(std::shared_ptr<EventStreamNode<E>>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+    { }
+
+    auto GetNodePtr() -> std::shared_ptr<EventStreamNode<E>>&
+        { return nodePtr_; }
+
+    auto GetNodePtr() const -> const std::shared_ptr<EventStreamNode<E>>&
+        { return nodePtr_; }
+
+    NodeId GetNodeId() const
+        { return nodePtr_->GetNodeId(); }
+
+    EventValueList<E>& Events()
+        { return nodePtr_->Events(); }
+
+    const EventValueList<E>& Events() const
+        { return nodePtr_->Events(); }
+
+private:
+    std::shared_ptr<EventStreamNode<E>> nodePtr_;
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_GRAPH_EVENTNODES_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_EVENT_NODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/PropagationMT.h b/include/react/detail/graph/PropagationMT.h
deleted file mode 100644
index e69de29b..00000000
diff --git a/include/react/detail/graph/PropagationST.h b/include/react/detail/graph/PropagationST.h
deleted file mode 100644
index 2fc0d048..00000000
--- a/include/react/detail/graph/PropagationST.h
+++ /dev/null
@@ -1,500 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
-#define REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <algorithm>
-#include <atomic>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include <map>
-#include <mutex>
-
-#include <tbb/concurrent_queue.h>
-#include <tbb/task.h>
-
-#include "react/common/Containers.h"
-#include "react/common/Types.h"
-#include "react/detail/IReactiveGraph.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <typename K>
-class PtrCache
-{
-public:
-    template <typename V, typename F>
-    std::shared_ptr<V> LookupOrCreate(const K& key, F&& createFunc)
-    {
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-
-        auto it = map1_.find(key);
-
-        if (it != map1_.end())
-        {
-            if (auto ptr = it->second.lock())
-            {
-                return std::static_pointer_cast<V>(ptr);
-            }
-        }
-
-        std::shared_ptr<V> v = createFunc();
-        auto res = map1_.insert({ key, std::weak_ptr<void>{ v } });
-        map2_[v.get()] = res.first;
-        return v;
-    }
-
-    template <typename V>
-    void Erase(V* ptr)
-    {
-        std::lock_guard<std::mutex> scopedLock(mutex_);
-
-        auto it = map2_.find((void*)ptr);
-
-        if (it != map2_.end())
-        {
-            map1_.erase(it->second);
-            map2_.erase(it);
-        }
-    }
-
-private:
-    std::mutex  mutex_;
-
-    using Map1Type = std::map<K, std::weak_ptr<void>>;
-    using Map2Type = std::unordered_map<void*, typename Map1Type::iterator>;
-
-    Map1Type map1_;
-    Map2Type map2_;
-};
-
-class ReactiveGraph;
-
-class TransactionQueue
-{
-public:
-    TransactionQueue(ReactiveGraph& graph) :
-        graph_( graph )
-        { }
-
-    TransactionQueue(const TransactionQueue&) = delete;
-    TransactionQueue& operator=(const TransactionQueue&) = delete;
-
-    TransactionQueue(TransactionQueue&&) = default;
-    TransactionQueue& operator =(TransactionQueue&&) = default;
-
-    template <typename F>
-    void Push(TransactionFlags flags, F&& transaction)
-    {
-        transactions_.push(StoredTransaction{ flags, std::forward<F>(transaction) });
-
-        if (count_.fetch_add(1, std::memory_order_relaxed) == 0)
-            tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(*this));
-    }
-
-private:
-    struct StoredTransaction
-    {
-        TransactionFlags        flags;
-        std::function<void()>   callback;
-    };
-
-    class WorkerTask : public tbb::task
-    {
-    public:
-        WorkerTask(TransactionQueue& parent) :
-            parent_( parent )
-            { }
-
-        tbb::task* execute()
-        {
-            parent_.ProcessQueue();
-            return nullptr;
-        }
-
-    private:
-        TransactionQueue& parent_;
-    };
-
-    void ProcessQueue();
-
-    size_t ProcessNextBatch();
-
-    tbb::concurrent_queue<StoredTransaction> transactions_;
-
-    std::atomic<size_t> count_{ 0 };
-
-    ReactiveGraph& graph_;
-};
-
-class ReactiveGraph
-{
-public:
-    using LinkCacheType = PtrCache<std::pair<void*, void*>>;
-
-    NodeId RegisterNode(IReactiveNode* nodePtr, NodeCategory category);
-    void UnregisterNode(NodeId nodeId);
-
-    void OnNodeAttach(NodeId node, NodeId parentId);
-    void OnNodeDetach(NodeId node, NodeId parentId);
-
-    template <typename F>
-    void AddInput(NodeId nodeId, F&& inputCallback);
-
-    template <typename F>
-    void DoTransaction(F&& transactionCallback);
-
-    template <typename F>
-    void EnqueueTransaction(TransactionFlags flags, F&& transactionCallback);
-    
-    LinkCacheType& GetLinkCache()
-        { return linkCache_; }
-
-private:
-    struct NodeData
-    {
-        NodeData() = default;
-
-        NodeData(const NodeData&) = default;
-        NodeData& operator=(const NodeData&) = default;
-
-        NodeData(IReactiveNode* nodePtrIn, NodeCategory categoryIn) :
-            nodePtr( nodePtrIn ),
-            category(categoryIn)
-            { }
-
-        NodeCategory category = NodeCategory::normal;
-
-        int     level       = 0;
-        int     newLevel    = 0 ;
-        bool    queued      = false;
-
-        IReactiveNode*  nodePtr = nullptr;
-
-        std::vector<NodeId> successors;
-    };
-
-    class TopoQueue
-    {
-    public:
-        void Push(NodeId nodeId, int level)
-            { queueData_.emplace_back(nodeId, level); }
-
-        bool FetchNext();
-
-        const std::vector<NodeId>& Next() const
-            { return nextData_; }
-
-        bool IsEmpty() const
-            { return queueData_.empty(); }
-
-    private:
-        using Entry = std::pair<NodeId /*nodeId*/, int /*level*/>;
-
-        std::vector<Entry>  queueData_;
-        std::vector<NodeId> nextData_;
-
-        int minLevel_ = (std::numeric_limits<int>::max)();
-    };
-
-    void Propagate();
-    void UpdateLinkNodes();
-
-    void ScheduleSuccessors(NodeData & node);
-    void InvalidateSuccessors(NodeData & node);
-
-private:
-    TransactionQueue    transactionQueue_{ *this };
-
-    IndexedStorage<NodeData>    nodeData_;
-
-    TopoQueue           scheduledNodes_;
-    std::vector<NodeId> changedInputs_;
-    LinkOutputMap       scheduledLinkOutputs_;
-
-    LinkCacheType       linkCache_;
-
-    bool isTransactionActive_ = false;
-};
-
-NodeId ReactiveGraph::RegisterNode(IReactiveNode* nodePtr, NodeCategory category)
-{
-    return nodeData_.Insert(NodeData{ nodePtr, category });
-}
-
-void ReactiveGraph::UnregisterNode(NodeId nodeId)
-{
-    nodeData_.Erase(nodeId);
-}
-
-void ReactiveGraph::OnNodeAttach(NodeId nodeId, NodeId parentId)
-{
-    auto& node = nodeData_[nodeId];
-    auto& parent = nodeData_[parentId];
-
-    parent.successors.push_back(nodeId);
-
-    if (node.level <= parent.level)
-        node.level = parent.level + 1;
-}
-
-void ReactiveGraph::OnNodeDetach(NodeId nodeId, NodeId parentId)
-{
-    auto& parent = nodeData_[parentId];
-    auto& successors = parent.successors;
-
-    successors.erase(std::find(successors.begin(), successors.end(), nodeId));
-}
-
-template <typename F>
-void ReactiveGraph::AddInput(NodeId nodeId, F&& inputCallback)
-{
-    auto& node = nodeData_[nodeId];
-    auto* nodePtr = node.nodePtr;
-
-    // This writes to the input buffer of the respective node.
-    inputCallback();
-    
-    if (isTransactionActive_)
-    {
-        // If a transaction is active, don't propagate immediately.
-        // Instead, record the node and wait for more inputs.
-        changedInputs_.push_back(nodeId);
-    }
-    else
-    {
-        size_t successorCount = node.successors.size();
-
-        // Update the node. This applies the input buffer to the node value and checks if it changed.
-        if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
-        {
-            // Propagate changes through the graph
-            ScheduleSuccessors(node);
-
-            if (! scheduledNodes_.IsEmpty())
-                Propagate();
-
-            if (! scheduledLinkOutputs_.empty())
-                UpdateLinkNodes();
-        }
-    }
-}
-
-template <typename F>
-void ReactiveGraph::DoTransaction(F&& transactionCallback)
-{
-    // Transaction callback may add multiple inputs.
-    isTransactionActive_ = true;
-    std::forward<F>(transactionCallback)();
-    isTransactionActive_ = false;
-
-    // Apply all buffered inputs.
-    for (NodeId nodeId : changedInputs_)
-    {
-        auto& node = nodeData_[nodeId];
-        auto* nodePtr = node.nodePtr;
-
-        size_t successorCount = node.successors.size();
-
-        if (nodePtr->Update(0, successorCount) == UpdateResult::changed)
-        {
-            if (node.category == NodeCategory::dyninput)
-                InvalidateSuccessors(node);
-
-            ScheduleSuccessors(node);
-        }
-    }
-
-    changedInputs_.clear();
-
-    // Propagate changes through the graph.
-    if (! scheduledNodes_.IsEmpty())
-        Propagate();
-
-    if (! scheduledLinkOutputs_.empty())
-        UpdateLinkNodes();
-}
-
-template <typename F>
-void ReactiveGraph::EnqueueTransaction(TransactionFlags flags, F&& transactionCallback)
-{
-    transactionQueue_.Push(flags, std::forward<F>(transactionCallback));
-}
-
-void ReactiveGraph::Propagate()
-{
-    while (scheduledNodes_.FetchNext())
-    {
-        for (NodeId nodeId : scheduledNodes_.Next())
-        {
-            auto& node = nodeData_[nodeId];
-            auto* nodePtr = node.nodePtr;
-
-            if (node.level < node.newLevel)
-            {
-                // Re-schedule this node
-                node.level = node.newLevel;
-                InvalidateSuccessors(node);
-                scheduledNodes_.Push(nodeId, node.level);
-                continue;
-            }
-
-            // Special handling for link output nodes. They have no successors and they don't have to be updated.
-            if (node.category == NodeCategory::linkoutput)
-            {
-                static_cast<ILinkOutputNode*>(node.nodePtr)->CollectOutput(scheduledLinkOutputs_);
-                continue;
-            }
-
-            size_t successorCount = node.successors.size();
-
-            if (nodePtr->Update(0u, successorCount) == UpdateResult::changed)
-            {
-                ScheduleSuccessors(node);
-            }
-
-            node.queued = false;
-        }
-    }
-}
-
-void ReactiveGraph::UpdateLinkNodes()
-{
-    for (auto& e : scheduledLinkOutputs_)
-    {
-        e.first->EnqueueTransaction(TransactionFlags::none,
-            [inputs = std::move(e.second)]
-            {
-                for (auto& callback : inputs)
-                    callback();
-            });
-    }
-
-    scheduledLinkOutputs_.clear();
-}
-
-void ReactiveGraph::ScheduleSuccessors(NodeData& node)
-{
-    for (NodeId succId : node.successors)
-    {
-        auto& succ = nodeData_[succId];
-
-        if (!succ.queued)
-        {
-            succ.queued = true;
-            scheduledNodes_.Push(succId, succ.level);
-        }
-    }
-}
-
-void ReactiveGraph::InvalidateSuccessors(NodeData& node)
-{
-    for (NodeId succId : node.successors)
-    {
-        auto& succ = nodeData_[succId];
-
-        if (succ.newLevel <= node.level)
-            succ.newLevel = node.level + 1;
-    }
-}
-
-bool ReactiveGraph::TopoQueue::FetchNext()
-{
-    // Throw away previous values
-    nextData_.clear();
-
-    // Find min level of nodes in queue data
-    minLevel_ = (std::numeric_limits<int>::max)();
-    for (const auto& e : queueData_)
-        if (minLevel_ > e.second)
-            minLevel_ = e.second;
-
-    // Swap entries with min level to the end
-    auto p = std::partition(queueData_.begin(), queueData_.end(), [t = minLevel_] (const Entry& e) { return t != e.second; });
-
-    // Move min level values to next data
-    nextData_.reserve(std::distance(p, queueData_.end()));
-
-    for (auto it = p; it != queueData_.end(); ++it)
-        nextData_.push_back(it->first);
-
-    // Truncate moved entries
-    queueData_.resize(std::distance(queueData_.begin(), p));
-
-    return !nextData_.empty();
-}
-
-void TransactionQueue::ProcessQueue()
-{
-    for (;;)
-    {
-        size_t popCount = ProcessNextBatch();
-        if (count_.fetch_sub(popCount) == popCount)
-            return;
-    }
-}
-
-size_t TransactionQueue::ProcessNextBatch()
-{
-    StoredTransaction curTransaction;
-    size_t popCount = 0;
-    bool canMerge = false;
-    bool skipPop = false;
-    bool isDone = false;
-
-    // Outer loop. One transaction per iteration.
-    for (;;)
-    {
-        if (!skipPop)
-        {
-            if (!transactions_.try_pop(curTransaction))
-                return popCount;
-
-            canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
-            ++popCount;
-        }
-        else
-        {
-            skipPop = false;
-        }
-
-        graph_.DoTransaction([&]
-        {
-            curTransaction.callback();
-
-            if (canMerge)
-            {
-                // Inner loop. Mergeable transactions are merged
-                for (;;)
-                {
-                    if (transactions_.try_pop(curTransaction))
-                        return;
-
-                    canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
-                    ++popCount;
-
-                    if (!canMerge)
-                    {
-                        skipPop = true;
-                        return;
-                    }
-
-                    curTransaction.callback();
-                }
-            }
-        });
-    }
-}
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_DETAIL_GRAPH_PROPAGATIONST_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph_impl.h b/include/react/detail/graph_impl.h
new file mode 100644
index 00000000..133ffbe6
--- /dev/null
+++ b/include/react/detail/graph_impl.h
@@ -0,0 +1,224 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef REACT_DETAIL_PROPAGATION_H_INCLUDED
+#define REACT_DETAIL_PROPAGATION_H_INCLUDED
+
+#pragma once
+
+#include "react/detail/defs.h"
+
+#include <algorithm>
+#include <atomic>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <map>
+#include <mutex>
+#include <optional>
+
+#include <tbb/concurrent_queue.h>
+#include <tbb/task.h>
+
+#include "react/common/ptrcache.h"
+#include "react/common/slotmap.h"
+#include "react/common/syncpoint.h"
+#include "react/detail/graph_interface.h"
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+class ReactGraph;
+
+class TransactionQueue
+{
+public:
+    TransactionQueue(ReactGraph& graph) :
+        graph_( graph )
+    { }
+
+    TransactionQueue(const TransactionQueue&) = delete;
+    TransactionQueue& operator=(const TransactionQueue&) = delete;
+
+    TransactionQueue(TransactionQueue&&) = default;
+    TransactionQueue& operator =(TransactionQueue&&) = default;
+
+    template <typename F>
+    void Push(F&& func, SyncPoint::Dependency dep, TransactionFlags flags)
+    {
+        transactions_.push(StoredTransaction{ std::forward<F>(transaction), std::move(dep), flags });
+
+        if (count_.fetch_add(1, std::memory_order_release) == 0)
+            tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(*this));
+    }
+
+private:
+    struct StoredTransaction
+    {
+        std::function<void()>       func;
+        SyncPoint::DependencyList   deps;
+        TransactionFlags            flags;
+    };
+
+    class WorkerTask : public tbb::task
+    {
+    public:
+        WorkerTask(TransactionQueue& parent) :
+            parent_( parent )
+            { }
+
+        tbb::task* execute()
+        {
+            parent_.ProcessQueue();
+            return nullptr;
+        }
+
+    private:
+        TransactionQueue& parent_;
+    };
+
+    void ProcessQueue();
+
+    size_t ProcessNextBatch();
+
+    tbb::concurrent_queue<StoredTransaction> transactions_;
+
+    std::atomic<size_t> count_{ 0 };
+
+    ReactGraph& graph_;
+};
+
+class ReactGraph
+{
+public:
+    using LinkCache = WeakPtrCache<void*, IReactNode>;
+
+    NodeId RegisterNode(IReactNode* nodePtr, NodeCategory category);
+    void UnregisterNode(NodeId nodeId);
+
+    void AttachNode(NodeId node, NodeId parentId);
+    void DetachNode(NodeId node, NodeId parentId);
+
+    template <typename F>
+    void PushInput(NodeId nodeId, F&& inputCallback);
+
+    void PushDependency(SyncPoint::Dependency dep);
+
+    template <typename F>
+    void DoTransaction(F&& transactionCallback);
+
+    template <typename F>
+    void EnqueueTransaction(F&& func, SyncPoint::DependencyList&& deps, TransactionFlags flags);
+    
+    LinkCache& GetLinkCache()
+        { return linkCache_; }
+
+private:
+    struct NodeData
+    {
+        NodeData() = default;
+
+        NodeData(const NodeData&) = default;
+        NodeData& operator=(const NodeData&) = default;
+
+        NodeData(IReactNode* nodePtrIn, NodeCategory categoryIn) :
+            nodePtr( nodePtrIn ),
+            category(categoryIn)
+        { }
+
+        NodeCategory category = NodeCategory::normal;
+
+        int     level       = 0;
+        int     newLevel    = 0 ;
+        bool    queued      = false;
+
+        IReactNode*  nodePtr = nullptr;
+
+        std::vector<NodeId> successors;
+    };
+
+    class TopoQueue
+    {
+    public:
+        void Push(NodeId nodeId, int level)
+            { queueData_.emplace_back(nodeId, level); }
+
+        bool FetchNext();
+
+        const std::vector<NodeId>& Next() const
+            { return nextData_; }
+
+        bool IsEmpty() const
+            { return queueData_.empty(); }
+
+    private:
+        using Entry = std::pair<NodeId /*nodeId*/, int /*level*/>;
+
+        std::vector<Entry>  queueData_;
+        std::vector<NodeId> nextData_;
+
+        int minLevel_ = (std::numeric_limits<int>::max)();
+    };
+
+    void Propagate();
+    void UpdateLinkNodes();
+
+    void ScheduleSuccessors(NodeData & node);
+    void RecalculateSuccessorLevels(NodeData & node);
+
+private:
+    TransactionQueue    transactionQueue_{ *this };
+
+    SlotMap<NodeData>   nodeData_;
+
+    TopoQueue           scheduledNodes_;
+
+    std::vector<NodeId>         changedInputs_;
+    std::vector<IReactNode*>    changedNodes_;
+
+    std::vector<SyncPoint::Dependency> curDependencies_;
+
+    LinkOutputMap       scheduledLinkOutputs_;
+
+    LinkCache           linkCache_;
+
+    bool isTransactionActive_ = false;
+};
+
+template <typename F>
+void ReactGraph::PushInput(NodeId nodeId, F&& inputCallback)
+{
+    auto& node = nodeData_[nodeId];
+    auto* nodePtr = node.nodePtr;
+
+    // This writes to the input buffer of the respective node.
+    std::forward<F>(inputCallback)();
+    
+    changedInputs_.push_back(nodeId);
+
+    if (!isTransactionActive_)
+        Propagate();
+}
+
+template <typename F>
+void ReactGraph::DoTransaction(F&& transactionCallback)
+{
+    // Transaction callback may add multiple inputs.
+    isTransactionActive_ = true;
+    std::forward<F>(transactionCallback)();
+    isTransactionActive_ = false;
+
+    Propagate();
+}
+
+template <typename F>
+void ReactGraph::EnqueueTransaction(F&& func, SyncPoint::DependencyList&& deps, TransactionFlags flags)
+{
+    transactionQueue_.Push(std::forward<F>(func), std::move(deps), flags);
+}
+
+/****************************************/ REACT_IMPL_END /***************************************/
+
+#endif // REACT_DETAIL_PROPAGATION_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/IReactiveGraph.h b/include/react/detail/graph_interface.h
similarity index 63%
rename from include/react/detail/IReactiveGraph.h
rename to include/react/detail/graph_interface.h
index 85f3d253..6fa51f89 100644
--- a/include/react/detail/IReactiveGraph.h
+++ b/include/react/detail/graph_interface.h
@@ -1,24 +1,24 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
-#define REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
+#ifndef REACT_DETAIL_GRAPH_INTERFACE_H_INCLUDED
+#define REACT_DETAIL_GRAPH_INTERFACE_H_INCLUDED
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <functional>
 #include <memory>
 #include <unordered_map>
 #include <utility>
 
-#include "react/API.h"
-#include "react/common/Types.h"
-#include "react/common/Util.h"
+#include "react/api.h"
+#include "react/common/types.h"
+#include "react/common/utility.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
@@ -48,29 +48,29 @@ enum class NodeCategory
     linkoutput
 };
 
-class ReactiveGraph;
+class ReactGraph;
+struct IReactNode;
+
+using LinkOutputMap = std::unordered_map<ReactGraph*, std::vector<std::function<void()>>>;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IReactiveNode
+/// IReactNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-struct IReactiveNode
+struct IReactNode
 {
-    virtual ~IReactiveNode() = default;
-
-    virtual const char* GetNodeType() const = 0;
+    virtual ~IReactNode() = default;
 
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) = 0;
+    virtual UpdateResult Update(TurnId turnId) noexcept = 0;
+    
+    virtual void Clear() noexcept
+        { }
 
-    virtual int GetDependencyCount() const = 0;
+    virtual void CollectOutput(LinkOutputMap& output)
+        { }
 };
 
-using LinkOutputMap = std::unordered_map<ReactiveGraph*, std::vector<std::function<void()>>>;
 
-struct ILinkOutputNode : public IReactiveNode
-{
-    virtual void CollectOutput(LinkOutputMap& output) = 0;
-};
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_IREACTIVEENGINE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_GRAPH_INTERFACE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/GraphBase.h b/include/react/detail/node_base.h
similarity index 65%
rename from include/react/detail/graph/GraphBase.h
rename to include/react/detail/node_base.h
index 65f8d1f7..6345d431 100644
--- a/include/react/detail/graph/GraphBase.h
+++ b/include/react/detail/node_base.h
@@ -1,37 +1,47 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DETAIL_GRAPH_GRAPHBASE_H_INCLUDED
-#define REACT_DETAIL_GRAPH_GRAPHBASE_H_INCLUDED
+#ifndef REACT_DETAIL_NODE_BASE_H_INCLUDED
+#define REACT_DETAIL_NODE_BASE_H_INCLUDED
 
 #pragma once
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <iterator>
 #include <memory>
 #include <utility>
 
-#include "react/common/Types.h"
-#include "react/common/Util.h"
-#include "react/detail/IReactiveGraph.h"
+#include "react/common/types.h"
+#include "react/common/utility.h"
+#include "react/detail/graph_interface.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-class ReactiveGraph;
+class ReactGraph;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// CreateWrappedNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename RET, typename NODE, typename ... ARGS>
+static RET CreateWrappedNode(ARGS&& ... args)
+{
+    auto node = std::make_shared<NODE>(std::forward<ARGS>(args) ...);
+    return RET(std::move(node));
+}
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// NodeBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-class NodeBase : public IReactiveNode
+class NodeBase : public IReactNode
 {
 public:
     NodeBase(const Group& group) :
         group_( group )
-        { }
+    { }
     
     NodeBase(const NodeBase&) = delete;
     NodeBase& operator=(const NodeBase&) = delete;
@@ -65,10 +75,10 @@ class NodeBase : public IReactiveNode
         { return group_; }
 
 protected:
-    auto GetGraphPtr() const -> const std::shared_ptr<ReactiveGraph>&
+    auto GetGraphPtr() const -> const std::shared_ptr<ReactGraph>&
         { return GetInternals(group_).GetGraphPtr(); }
 
-    auto GetGraphPtr() -> std::shared_ptr<ReactiveGraph>&
+    auto GetGraphPtr() -> std::shared_ptr<ReactGraph>&
         { return GetInternals(group_).GetGraphPtr(); }
 
     void RegisterMe(NodeCategory category = NodeCategory::normal)
@@ -78,10 +88,10 @@ class NodeBase : public IReactiveNode
         { GetGraphPtr()->UnregisterNode(nodeId_); }
 
     void AttachToMe(NodeId otherNodeId)
-        { GetGraphPtr()->OnNodeAttach(nodeId_, otherNodeId); }
+        { GetGraphPtr()->AttachNode(nodeId_, otherNodeId); }
 
     void DetachFromMe(NodeId otherNodeId)
-        { GetGraphPtr()->OnNodeDetach(nodeId_, otherNodeId); }
+        { GetGraphPtr()->DetachNode(nodeId_, otherNodeId); }
 
 private:
     NodeId nodeId_;
@@ -91,4 +101,4 @@ class NodeBase : public IReactiveNode
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_GRAPH_GRAPHBASE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_NODE_BASE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/ObserverNodes.h b/include/react/detail/observer_nodes.h
similarity index 69%
rename from include/react/detail/graph/ObserverNodes.h
rename to include/react/detail/observer_nodes.h
index 695c0792..35c160b1 100644
--- a/include/react/detail/graph/ObserverNodes.h
+++ b/include/react/detail/observer_nodes.h
@@ -1,23 +1,21 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DETAIL_GRAPH_OBSERVERNODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_OBSERVERNODES_H_INCLUDED
+#ifndef REACT_DETAIL_OBSERVER_NODES_H_INCLUDED
+#define REACT_DETAIL_OBSERVER_NODES_H_INCLUDED
 
 #pragma once
 
-#include "react/detail/Defs.h"
-#include "react/API.h"
+#include "react/detail/defs.h"
+#include "react/api.h"
 
 #include <memory>
 #include <utility>
 
-#include "GraphBase.h"
-
-#include "react/detail/ReactiveInput.h"
+#include "node_base.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
@@ -36,9 +34,9 @@ class EventStreamNode;
 class ObserverNode : public NodeBase
 {
 public:
-    ObserverNode(const Group& group) :
+    explicit ObserverNode(const Group& group) :
         ObserverNode::NodeBase( group )
-        { }
+    { }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -60,19 +58,14 @@ class SignalObserverNode : public ObserverNode
 
     ~SignalObserverNode()
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
+        std::apply([this] (const auto& ... deps)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SignalObserver"; }
-
-    virtual int GetDependencyCount() const override
-        { return sizeof...(TDeps); }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        apply([this] (const auto& ... deps) { this->func_(GetInternals(deps).Value() ...); }, depHolder_);
+        std::apply([this] (const auto& ... deps) { this->func_(GetInternals(deps).Value() ...); }, depHolder_);
         return UpdateResult::unchanged;
     }
 
@@ -105,16 +98,9 @@ class EventObserverNode : public ObserverNode
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "EventObserver"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        func_(EventRange<E>( GetInternals(subject_).Events() ));
-        GetInternals(subject_).DecrementPendingSuccessorCount();
+        func_(GetInternals(subject_).Events());
         return UpdateResult::unchanged;
     }
 
@@ -145,26 +131,20 @@ class SyncedEventObserverNode : public ObserverNode
 
     ~SyncedEventObserverNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        std::apply([this] (const auto& ... syncs)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(subject_).GetNodeId());
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SyncedEventObserver"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1 + sizeof...(TSyncs); }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
         if (GetInternals(this->subject_).Events().empty())
             return UpdateResult::unchanged;
 
-        apply([this] (const auto& ... syncs) { func_(EventRange<E>( GetInternals(this->subject_).Events() ), GetInternals(syncs).Value() ...); }, syncHolder_);
-
-        GetInternals(subject_).DecrementPendingSuccessorCount();
+        std::apply([this] (const auto& ... syncs)
+            { func_(EventRange<E>( GetInternals(this->subject_).Events() ), GetInternals(syncs).Value() ...); }, syncHolder_);
 
         return UpdateResult::unchanged;
     }
@@ -179,4 +159,4 @@ class SyncedEventObserverNode : public ObserverNode
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_GRAPH_OBSERVERNODES_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_OBSERVER_NODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph/SignalNodes.h b/include/react/detail/signal_nodes.h
similarity index 74%
rename from include/react/detail/graph/SignalNodes.h
rename to include/react/detail/signal_nodes.h
index 268faf7c..f97dc908 100644
--- a/include/react/detail/graph/SignalNodes.h
+++ b/include/react/detail/signal_nodes.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -9,14 +9,14 @@
 #ifndef REACT_DETAIL_GRAPH_SIGNALNODES_H_INCLUDED
 #define REACT_DETAIL_GRAPH_SIGNALNODES_H_INCLUDED
 
-#include "react/detail/Defs.h"
+#include "react/detail/defs.h"
 
 #include <memory>
 #include <queue>
 #include <utility>
 #include <vector>
 
-#include "GraphBase.h"
+#include "node_base.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
@@ -42,13 +42,13 @@ class SignalNode : public NodeBase
     explicit SignalNode(const Group& group) :
         SignalNode::NodeBase( group ),
         value_( )
-        { }
+    { }
 
     template <typename T>
     SignalNode(const Group& group, T&& value) :
         SignalNode::NodeBase( group ),
         value_( std::forward<T>(value) )
-        { }
+    { }
 
     S& Value()
         { return value_; }
@@ -87,13 +87,7 @@ class VarSignalNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "VarSignal"; }
-
-    virtual int GetDependencyCount() const override
-        { return 0; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         if (isInputAdded_)
         {
@@ -149,7 +143,7 @@ class VarSignalNode : public SignalNode<S>
         // in ApplyInput
         else
         {
-            func(newValue_);            
+            func(newValue_);
         }
     }
 
@@ -178,21 +172,17 @@ class SignalFuncNode : public SignalNode<S>
 
     ~SignalFuncNode()
     {
-        apply([this] (const auto& ... deps) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodePtr()->GetNodeId())); }, depHolder_);
+        std::apply([this] (const auto& ... deps)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodePtr()->GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SignalFunc"; }
-
-    virtual int GetDependencyCount() const override
-        { return sizeof...(TDeps); }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {   
         bool changed = false;
 
-        S newValue = apply([this] (const auto& ... deps) { return this->func_(GetInternals(deps).Value() ...); }, depHolder_);
+        S newValue = std::apply([this] (const auto& ... deps)
+            { return this->func_(GetInternals(deps).Value() ...); }, depHolder_);
 
         if (! (this->Value() == newValue))
         {
@@ -208,7 +198,6 @@ class SignalFuncNode : public SignalNode<S>
 
 private:
     F func_;
-
     std::tuple<Signal<TDeps> ...> depHolder_;
 };
 
@@ -224,8 +213,8 @@ class SignalSlotNode : public SignalNode<S>
         input_( dep )
     {
         inputNodeId_ = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
+        
         this->RegisterMe();
-
         this->AttachToMe(inputNodeId_);
         this->AttachToMe(GetInternals(dep).GetNodeId());
     }
@@ -234,18 +223,12 @@ class SignalSlotNode : public SignalNode<S>
     {
         this->DetachFromMe(GetInternals(input_).GetNodeId());
         this->DetachFromMe(inputNodeId_);
-
         this->UnregisterMe();
+
         GetGraphPtr()->UnregisterNode(inputNodeId_);
     }
 
-    virtual const char* GetNodeType() const override
-        { return "SignalSlot"; }
-
-    virtual int GetDependencyCount() const override
-        { return 2; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         if (! (this->Value() == GetInternals(input_).Value()))
         {
@@ -273,20 +256,13 @@ class SignalSlotNode : public SignalNode<S>
         { return inputNodeId_; }
 
 private:        
-    struct VirtualInputNode : public IReactiveNode
+    struct VirtualInputNode : public IReactNode
     {
-        virtual const char* GetNodeType() const override
-            { return "SignalSlotInput"; }
-
-        virtual int GetDependencyCount() const override
-            { return 0; }
-
-        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+        virtual UpdateResult Update(TurnId turnId) noexcept override
             { return UpdateResult::changed; }
     };
 
-    Signal<S> input_;
-
+    Signal<S>           input_;
     NodeId              inputNodeId_;
     VirtualInputNode    slotInput_;
     
@@ -301,13 +277,24 @@ class SignalLinkNode : public SignalNode<S>
 public:
     SignalLinkNode(const Group& group, const Signal<S>& dep) :
         SignalLinkNode::SignalNode( group, GetInternals(dep).Value() ),
-        linkOutput_( dep )
+        dep_ ( dep )
     {
         this->RegisterMe(NodeCategory::input);
+
+        auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
+        outputNodeId_ = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
+        
+        srcGraphPtr->AttachNode(outputNodeId_, GetInternals(dep).GetNodeId());
     }
 
     ~SignalLinkNode()
     {
+        this->DetachFromMe(GetInternals(dep_).GetNodeId());
+
+        auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
+        srcGraphPtr->DetachNode(outputNodeId_, GetInternals(dep_).GetNodeId());
+        srcGraphPtr->UnregisterNode(outputNodeId_);
+
         auto& linkCache = GetGraphPtr()->GetLinkCache();
         linkCache.Erase(this);
 
@@ -317,46 +304,16 @@ class SignalLinkNode : public SignalNode<S>
     void SetWeakSelfPtr(const std::weak_ptr<SignalLinkNode>& self)
         { linkOutput_.parent = self; }
 
-    virtual const char* GetNodeType() const override
-        { return "SignalLink"; }
-
-    virtual int GetDependencyCount() const override
-        { return 1; }
-
-    virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+    virtual UpdateResult Update(TurnId turnId) noexcept override
         { return UpdateResult::changed; }
 
-    template <typename T>
-    void SetValue(T&& newValue)
-        { this->Value() = std::forward<T>(newValue); }
+    void SetValue(S&& newValue)
+        { this->Value() = std::move(newValue); }
 
 private:
-    struct VirtualOutputNode : public ILinkOutputNode
+    struct VirtualOutputNode : public IReactNode
     {
-        VirtualOutputNode(const Signal<S>& depIn) :
-            parent( ),
-            dep( depIn ),
-            srcGroup( depIn.GetGroup() )
-        {
-            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
-            nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-            srcGraphPtr->OnNodeAttach(nodeId, GetInternals(dep).GetNodeId());
-        }
-
-        ~VirtualOutputNode()
-        {
-            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
-            srcGraphPtr->OnNodeDetach(nodeId, GetInternals(dep).GetNodeId());
-            srcGraphPtr->UnregisterNode(nodeId);
-        }
-
-        virtual const char* GetNodeType() const override
-            { return "SignalLinkOutput"; }
-
-        virtual int GetDependencyCount() const override
-            { return 1; }
-
-        virtual UpdateResult Update(TurnId turnId, size_t successorCount) override
+        virtual UpdateResult Update(TurnId turnId) noexcept override
             { return UpdateResult::changed; }
 
         virtual void CollectOutput(LinkOutputMap& output) override
@@ -365,7 +322,7 @@ class SignalLinkNode : public SignalNode<S>
             {
                 auto* rawPtr = p->GetGraphPtr().get();
                 output[rawPtr].push_back(
-                    [storedParent = std::move(p), storedValue = GetInternals(dep).Value()]
+                    [storedParent = std::move(p), storedValue = GetInternals(p->dep_).Value()] () mutable -> void
                     {
                         NodeId nodeId = storedParent->GetNodeId();
                         auto& graphPtr = storedParent->GetGraphPtr();
@@ -380,15 +337,51 @@ class SignalLinkNode : public SignalNode<S>
         }
 
         std::weak_ptr<SignalLinkNode> parent;
-
-        NodeId      nodeId;
-        Signal<S>   dep;
-        Group       srcGroup;
     };
 
+    Signal<S>   dep_;
+    Group       srcGroup;
+    NodeId      outputNodeId_;
     VirtualOutputNode linkOutput_;
 };
 
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SignalInternals
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class SignalInternals
+{
+public:
+    SignalInternals(const SignalInternals&) = default;
+    SignalInternals& operator=(const SignalInternals&) = default;
+
+    SignalInternals(SignalInternals&&) = default;
+    SignalInternals& operator=(SignalInternals&&) = default;
+
+    explicit SignalInternals(std::shared_ptr<SignalNode<S>>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+    { }
+
+    auto GetNodePtr() -> std::shared_ptr<SignalNode<S>>&
+        { return nodePtr_; }
+
+    auto GetNodePtr() const -> const std::shared_ptr<SignalNode<S>>&
+        { return nodePtr_; }
+
+    NodeId GetNodeId() const
+        { return nodePtr_->GetNodeId(); }
+
+    S& Value()
+        { return nodePtr_->Value(); }
+
+    const S& Value() const
+        { return nodePtr_->Value(); }
+
+private:
+    std::shared_ptr<SignalNode<S>> nodePtr_;
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_SIGNALNODES_H_INCLUDED
\ No newline at end of file
diff --git a/project/msvc/CppReact.sln b/project/msvc/CppReact.sln
index bd00b26a..5f987e52 100644
--- a/project/msvc/CppReact.sln
+++ b/project/msvc/CppReact.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio 15
+VisualStudioVersion = 15.0.27004.2005
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CppReact", "CppReact.vcxproj", "{5E56AAB9-4E33-4B9E-A315-E85CEDB75CF1}"
 EndProject
@@ -31,6 +31,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicSignals", "Exa
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicSynchronization", "Example_BasicSynchronization.vcxproj", "{269329F8-A9E1-41AC-9C37-3A82A082A62C}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest-md", "..\..\..\googletest\googletest\msvc\2010\gtest-md.vcxproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main-md", "..\..\..\googletest\googletest\msvc\2010\gtest_main-md.vcxproj", "{3AF54C8A-10BF-4332-9147-F68ED9862033}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -119,6 +123,26 @@ Global
 		{269329F8-A9E1-41AC-9C37-3A82A082A62C}.Release|Win32.Build.0 = Release|Win32
 		{269329F8-A9E1-41AC-9C37-3A82A082A62C}.Release|x64.ActiveCfg = Release|x64
 		{269329F8-A9E1-41AC-9C37-3A82A082A62C}.Release|x64.Build.0 = Release|x64
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug|Win32.Build.0 = Debug|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug|x64.ActiveCfg = Debug|x64
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug|x64.Build.0 = Debug|x64
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release|Win32.ActiveCfg = Release|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release|Win32.Build.0 = Release|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release|x64.ActiveCfg = Release|x64
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release|x64.Build.0 = Release|x64
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug|Win32.Build.0 = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug|Win32.Deploy.0 = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug|x64.ActiveCfg = Debug|x64
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug|x64.Build.0 = Debug|x64
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug|x64.Deploy.0 = Debug|x64
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release|Win32.ActiveCfg = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release|Win32.Build.0 = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release|Win32.Deploy.0 = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release|x64.ActiveCfg = Release|x64
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release|x64.Build.0 = Release|x64
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release|x64.Deploy.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -134,5 +158,10 @@ Global
 		{CC66BFA0-D609-46E0-9FD1-F9CC902410B1} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{230C9137-CCD0-47E2-8F1F-2E1DD19984A1} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{269329F8-A9E1-41AC-9C37-3A82A082A62C} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8} = {3F97AA87-0A03-4428-94C1-C9B4007C2C80}
+		{3AF54C8A-10BF-4332-9147-F68ED9862033} = {3F97AA87-0A03-4428-94C1-C9B4007C2C80}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C336763D-6F55-40BD-B6E1-9CAE12FF54E0}
 	EndGlobalSection
 EndGlobal
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 6b961f03..68b88817 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -21,31 +21,32 @@
   <PropertyGroup Label="Globals">
     <ProjectGuid>{5E56AAB9-4E33-4B9E-A315-E85CEDB75CF1}</ProjectGuid>
     <RootNamespace>CppReact</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
@@ -105,6 +106,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Cpp0xSupport>true</Cpp0xSupport>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -143,6 +145,7 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Cpp0xSupport>true</Cpp0xSupport>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -154,32 +157,27 @@
     </Lib>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="..\..\include\react\API.h" />
-    <ClInclude Include="..\..\include\react\common\RefCounting.h" />
-    <ClInclude Include="..\..\include\react\common\Timing.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\ObserverNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\PropagationST.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\PropagationMT.h" />
-    <ClInclude Include="..\..\include\react\detail\ReactiveInput.h" />
-    <ClInclude Include="..\..\include\react\detail\Defs.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\AlgorithmNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h" />
-    <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h" />
-    <ClInclude Include="..\..\include\react\detail\IReactiveGraph.h" />
-    <ClInclude Include="..\..\include\react\Group.h" />
-    <ClInclude Include="..\..\include\react\common\Concurrency.h" />
-    <ClInclude Include="..\..\include\react\common\Containers.h" />
-    <ClInclude Include="..\..\include\react\common\SourceIdSet.h" />
-    <ClInclude Include="..\..\include\react\common\TopoQueue.h" />
-    <ClInclude Include="..\..\include\react\common\Types.h" />
-    <ClInclude Include="..\..\include\react\common\Util.h" />
-    <ClInclude Include="..\..\include\react\Algorithm.h" />
-    <ClInclude Include="..\..\include\react\Event.h" />
-    <ClInclude Include="..\..\include\react\Observer.h" />
-    <ClInclude Include="..\..\include\react\Signal.h" />
+    <ClInclude Include="..\..\include\react\algorithm.h" />
+    <ClInclude Include="..\..\include\react\api.h" />
+    <ClInclude Include="..\..\include\react\common\slotmap.h" />
+    <ClInclude Include="..\..\include\react\common\ptrcache.h" />
+    <ClInclude Include="..\..\include\react\common\syncpoint.h" />
+    <ClInclude Include="..\..\include\react\common\utility.h" />
+    <ClInclude Include="..\..\include\react\detail\algorithm_nodes.h" />
+    <ClInclude Include="..\..\include\react\detail\defs.h" />
+    <ClInclude Include="..\..\include\react\detail\event_nodes.h" />
+    <ClInclude Include="..\..\include\react\detail\graph_interface.h" />
+    <ClInclude Include="..\..\include\react\detail\node_base.h" />
+    <ClInclude Include="..\..\include\react\detail\observer_nodes.h" />
+    <ClInclude Include="..\..\include\react\detail\graph_impl.h" />
+    <ClInclude Include="..\..\include\react\detail\signal_nodes.h" />
+    <ClInclude Include="..\..\include\react\event.h" />
+    <ClInclude Include="..\..\include\react\group.h" />
+    <ClInclude Include="..\..\include\react\observer.h" />
+    <ClInclude Include="..\..\include\react\signal.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="..\..\src\detail\graph_impl.cpp" />
     <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp" />
     <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp" />
     <ClCompile Include="..\..\src\engine\ToposortEngine.cpp" />
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index c78bde77..d87af090 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -16,88 +16,70 @@
     <Filter Include="Header Files\detail">
       <UniqueIdentifier>{82fd9b9e-0b63-40f7-b245-b5eb0271b0d2}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\detail\graph">
-      <UniqueIdentifier>{c7adc39d-d19e-4fe2-b945-332515717bc8}</UniqueIdentifier>
-    </Filter>
     <Filter Include="Header Files\common">
       <UniqueIdentifier>{11a75126-8bfd-4693-be4b-4e06ab73450c}</UniqueIdentifier>
     </Filter>
     <Filter Include="Source Files\engine">
       <UniqueIdentifier>{3f444875-ab1a-4bbd-99eb-7018c930098a}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Source Files\detail">
+      <UniqueIdentifier>{45678bfc-0ce5-4e47-a365-54a72d8ecb6d}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="..\..\include\react\common\Containers.h">
-      <Filter>Header Files\common</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\common\SourceIdSet.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\api.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\common\TopoQueue.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\event.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\common\Types.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\group.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\common\Util.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\observer.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\common\Concurrency.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\signal.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\Defs.h">
+    <ClInclude Include="..\..\include\react\detail\algorithm_nodes.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\GraphBase.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\SignalNodes.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\ReactiveInput.h">
+    <ClInclude Include="..\..\include\react\detail\defs.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\AlgorithmNodes.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\ObserverNodes.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\EventNodes.h">
-      <Filter>Header Files\detail\graph</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\include\react\common\Timing.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\detail\event_nodes.h">
+      <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\common\RefCounting.h">
-      <Filter>Header Files\common</Filter>
+    <ClInclude Include="..\..\include\react\detail\graph_interface.h">
+      <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\IReactiveGraph.h">
+    <ClInclude Include="..\..\include\react\detail\node_base.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\PropagationST.h">
-      <Filter>Header Files\detail\graph</Filter>
+    <ClInclude Include="..\..\include\react\detail\observer_nodes.h">
+      <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\graph\PropagationMT.h">
-      <Filter>Header Files\detail\graph</Filter>
+    <ClInclude Include="..\..\include\react\detail\signal_nodes.h">
+      <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Algorithm.h">
+    <ClInclude Include="..\..\include\react\algorithm.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Event.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\include\react\detail\graph_impl.h">
+      <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Observer.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\include\react\common\slotmap.h">
+      <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Signal.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\include\react\common\ptrcache.h">
+      <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\API.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\include\react\common\syncpoint.h">
+      <Filter>Header Files\common</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\Group.h">
-      <Filter>Header Files</Filter>
+    <ClInclude Include="..\..\include\react\common\utility.h">
+      <Filter>Header Files\common</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
@@ -110,5 +92,8 @@
     <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp">
       <Filter>Source Files\engine</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\detail\graph_impl.cpp">
+      <Filter>Source Files\detail</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/project/msvc/CppReactBenchmark.vcxproj b/project/msvc/CppReactBenchmark.vcxproj
index a57e4b20..d6cd06b4 100644
--- a/project/msvc/CppReactBenchmark.vcxproj
+++ b/project/msvc/CppReactBenchmark.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/CppReactExample.vcxproj b/project/msvc/CppReactExample.vcxproj
index 34a714e6..65945095 100644
--- a/project/msvc/CppReactExample.vcxproj
+++ b/project/msvc/CppReactExample.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -27,26 +27,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/CppReactTest.vcxproj b/project/msvc/CppReactTest.vcxproj
index 5c2878a4..eccef6a3 100644
--- a/project/msvc/CppReactTest.vcxproj
+++ b/project/msvc/CppReactTest.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
@@ -93,26 +93,19 @@
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(GTestDir)\msvc\gtest-md\Debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>gtestd.lib;gtest_main-mdd.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)..\..\include;$(GTestDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_VARIADIC_MAX=10;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <Cpp0xSupport>true</Cpp0xSupport>
       <DisableSpecificWarnings>4503;%(DisableSpecificWarnings)</DisableSpecificWarnings>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(GTestDir)\msvc\gtest-md\Debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>gtestd.lib;gtest_main-mdd.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
@@ -141,12 +134,10 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
       <AdditionalIncludeDirectories>$(SolutionDir)..\..\include;$(GTestDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_VARIADIC_MAX=10;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <Cpp0xSupport>true</Cpp0xSupport>
       <DisableSpecificWarnings>4503;%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
@@ -155,40 +146,31 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>$(GTestDir)\msvc\gtest-md\Release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>gtest.lib;gtest_main-md.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <SubSystem>Console</SubSystem>
       <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\..\googletest\googletest\msvc\2010\gtest-md.vcxproj">
+      <Project>{c8f6c172-56f2-4e76-b5fa-c3b423b31be8}</Project>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\googletest\googletest\msvc\2010\gtest_main-md.vcxproj">
+      <Project>{3af54c8a-10bf-4332-9147-f68ed9862033}</Project>
+    </ProjectReference>
     <ProjectReference Include="CppReact.vcxproj">
       <Project>{5e56aab9-4e33-4b9e-a315-e85cedb75cf1}</Project>
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\tests\src\EventStreamTest.cpp" />
-    <ClCompile Include="..\..\tests\src\EventStreamTestQ.cpp" />
+    <ClCompile Include="..\..\tests\src\common_tests.cpp" />
+    <ClCompile Include="..\..\tests\src\event_tests.cpp" />
     <ClCompile Include="..\..\tests\src\MoveTest.cpp" />
     <ClCompile Include="..\..\tests\src\ObserverTest.cpp" />
-    <ClCompile Include="..\..\tests\src\ObserverTestQ.cpp" />
     <ClCompile Include="..\..\tests\src\OperationsTest.cpp" />
-    <ClCompile Include="..\..\tests\src\OperationsTestQ.cpp" />
     <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp" />
     <ClCompile Include="..\..\tests\src\SignalTest.cpp" />
-    <ClCompile Include="..\..\tests\src\SignalTestQ.cpp" />
     <ClCompile Include="..\..\tests\src\TransactionTest.cpp" />
   </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\..\tests\src\EventStreamTest.h" />
-    <ClInclude Include="..\..\tests\src\MoveTest.h" />
-    <ClInclude Include="..\..\tests\src\ObserverTest.h" />
-    <ClInclude Include="..\..\tests\src\OperationsTest.h" />
-    <ClInclude Include="..\..\tests\src\ParallelizationTest.h" />
-    <ClInclude Include="..\..\tests\src\SignalTest.h" />
-    <ClInclude Include="..\..\tests\src\TransactionTest.h" />
-    <ClInclude Include="..\..\tests\src\TestUtil.h" />
-  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
diff --git a/project/msvc/CppReactTest.vcxproj.filters b/project/msvc/CppReactTest.vcxproj.filters
index ae74e006..a6f9919a 100644
--- a/project/msvc/CppReactTest.vcxproj.filters
+++ b/project/msvc/CppReactTest.vcxproj.filters
@@ -15,64 +15,29 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\tests\src\EventStreamTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\tests\src\EventStreamTestQ.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\tests\src\MoveTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="..\..\tests\src\ObserverTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\ObserverTestQ.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\tests\src\OperationsTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\OperationsTestQ.cpp">
+    <ClCompile Include="..\..\tests\src\SignalTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\SignalTest.cpp">
+    <ClCompile Include="..\..\tests\src\TransactionTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\SignalTestQ.cpp">
+    <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\TransactionTest.cpp">
+    <ClCompile Include="..\..\tests\src\event_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp">
+    <ClCompile Include="..\..\tests\src\common_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\..\tests\src\EventStreamTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\MoveTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\ObserverTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\OperationsTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\SignalTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\TransactionTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\TestUtil.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\tests\src\ParallelizationTest.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/project/msvc/Example_BasicAlgorithms.vcxproj b/project/msvc/Example_BasicAlgorithms.vcxproj
index f77233e6..f376172b 100644
--- a/project/msvc/Example_BasicAlgorithms.vcxproj
+++ b/project/msvc/Example_BasicAlgorithms.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicComposition.vcxproj b/project/msvc/Example_BasicComposition.vcxproj
index 43101fb2..17164ed5 100644
--- a/project/msvc/Example_BasicComposition.vcxproj
+++ b/project/msvc/Example_BasicComposition.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicEvents.vcxproj b/project/msvc/Example_BasicEvents.vcxproj
index 07370926..c6d6256a 100644
--- a/project/msvc/Example_BasicEvents.vcxproj
+++ b/project/msvc/Example_BasicEvents.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicObservers.vcxproj b/project/msvc/Example_BasicObservers.vcxproj
index 7e27da42..ff78e91c 100644
--- a/project/msvc/Example_BasicObservers.vcxproj
+++ b/project/msvc/Example_BasicObservers.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicSignals.vcxproj b/project/msvc/Example_BasicSignals.vcxproj
index 556b2ad0..4e8cb03d 100644
--- a/project/msvc/Example_BasicSignals.vcxproj
+++ b/project/msvc/Example_BasicSignals.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/project/msvc/Example_BasicSynchronization.vcxproj b/project/msvc/Example_BasicSynchronization.vcxproj
index faa0ccfb..2de78be0 100644
--- a/project/msvc/Example_BasicSynchronization.vcxproj
+++ b/project/msvc/Example_BasicSynchronization.vcxproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -26,26 +26,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
diff --git a/src/detail/graph_impl.cpp b/src/detail/graph_impl.cpp
new file mode 100644
index 00000000..8dc4be9a
--- /dev/null
+++ b/src/detail/graph_impl.cpp
@@ -0,0 +1,248 @@
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include "react/detail/defs.h"
+
+#include <algorithm>
+#include <atomic>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <map>
+#include <mutex>
+
+#include <tbb/concurrent_queue.h>
+#include <tbb/task.h>
+
+#include "react/detail/graph_impl.h"
+
+#include "react/common/types.h"
+#include "react/common/expected.h"
+#include "react/detail/graph_interface.h"
+
+
+/***************************************/ REACT_IMPL_BEGIN /**************************************/
+
+NodeId ReactGraph::RegisterNode(IReactNode* nodePtr, NodeCategory category)
+{
+    return nodeData_.Insert(NodeData{ nodePtr, category });
+}
+
+void ReactGraph::UnregisterNode(NodeId nodeId)
+{
+    nodeData_.Erase(nodeId);
+}
+
+void ReactGraph::AttachNode(NodeId nodeId, NodeId parentId)
+{
+    auto& node = nodeData_[nodeId];
+    auto& parent = nodeData_[parentId];
+
+    parent.successors.push_back(nodeId);
+
+    if (node.level <= parent.level)
+        node.level = parent.level + 1;
+}
+
+void ReactGraph::DetachNode(NodeId nodeId, NodeId parentId)
+{
+    auto& parent = nodeData_[parentId];
+    auto& successors = parent.successors;
+
+    successors.erase(std::find(successors.begin(), successors.end(), nodeId));
+}
+
+void ReactGraph::PushDependency(SyncPoint::Dependency dep)
+{
+    curDependencies_.push_back(std::move(dep));
+}
+
+void ReactGraph::Propagate()
+{
+    // Fill update queue with successors of changed inputs.
+    for (NodeId nodeId : changedInputs_)
+    {
+        auto& node = nodeData_[nodeId];
+        auto* nodePtr = node.nodePtr;
+
+        if (nodePtr->Update(0u) == UpdateResult::changed)
+        {
+            changedNodes_.push_back(nodePtr);
+            ScheduleSuccessors(node);
+        }
+    }
+
+    // Propagate changes.
+    while (scheduledNodes_.FetchNext())
+    {
+        for (NodeId nodeId : scheduledNodes_.Next())
+        {
+            auto& node = nodeData_[nodeId];
+            auto* nodePtr = node.nodePtr;
+
+            if (node.level < node.newLevel)
+            {
+                // Re-schedule this node
+                node.level = node.newLevel;
+                RecalculateSuccessorLevels(node);
+                scheduledNodes_.Push(nodeId, node.level);
+                continue;
+            }
+
+            // Special handling for link output nodes. They have no successors and they don't have to be updated.
+            if (node.category == NodeCategory::linkoutput)
+            {
+                node.nodePtr->CollectOutput(scheduledLinkOutputs_);
+                continue;
+            }
+
+            if (nodePtr->Update(0u) == UpdateResult::changed)
+            {
+                changedNodes_.push_back(nodePtr);
+                ScheduleSuccessors(node);
+            }
+
+            node.queued = false;
+        }
+    }
+
+    if (!scheduledLinkOutputs_.empty())
+        UpdateLinkNodes();
+
+    // Cleanup buffers in changed nodes.
+    for (IReactNode* nodePtr : changedNodes_)
+        nodePtr->Clear();
+    changedNodes_.clear();
+}
+
+void ReactGraph::UpdateLinkNodes()
+{
+    for (auto& e : scheduledLinkOutputs_)
+    {
+        e.first->EnqueueTransaction(TransactionFlags::none,
+            [inputs = std::move(e.second)]
+            {
+                for (auto& callback : inputs)
+                    callback();
+            });
+    }
+
+    scheduledLinkOutputs_.clear();
+}
+
+void ReactGraph::ScheduleSuccessors(NodeData& node)
+{
+    for (NodeId succId : node.successors)
+    {
+        auto& succ = nodeData_[succId];
+
+        if (!succ.queued)
+        {
+            succ.queued = true;
+            scheduledNodes_.Push(succId, succ.level);
+        }
+    }
+}
+
+void ReactGraph::RecalculateSuccessorLevels(NodeData& node)
+{
+    for (NodeId succId : node.successors)
+    {
+        auto& succ = nodeData_[succId];
+
+        if (succ.newLevel <= node.level)
+            succ.newLevel = node.level + 1;
+    }
+}
+
+bool ReactGraph::TopoQueue::FetchNext()
+{
+    // Throw away previous values
+    nextData_.clear();
+
+    // Find min level of nodes in queue data
+    minLevel_ = (std::numeric_limits<int>::max)();
+    for (const auto& e : queueData_)
+        if (minLevel_ > e.second)
+            minLevel_ = e.second;
+
+    // Swap entries with min level to the end
+    auto p = std::partition(queueData_.begin(), queueData_.end(), [t = minLevel_] (const Entry& e) { return t != e.second; });
+
+    // Move min level values to next data
+    nextData_.reserve(std::distance(p, queueData_.end()));
+
+    for (auto it = p; it != queueData_.end(); ++it)
+        nextData_.push_back(it->first);
+
+    // Truncate moved entries
+    queueData_.resize(std::distance(queueData_.begin(), p));
+
+    return !nextData_.empty();
+}
+
+void TransactionQueue::ProcessQueue()
+{
+    for (;;)
+    {
+        size_t popCount = ProcessNextBatch();
+        if (count_.fetch_sub(popCount) == popCount)
+            return;
+    }
+}
+
+size_t TransactionQueue::ProcessNextBatch()
+{
+    StoredTransaction curTransaction;
+    size_t popCount = 0;
+    bool canMerge = false;
+    bool skipPop = false;
+    bool isDone = false;
+
+    // Outer loop. One transaction per iteration.
+    for (;;)
+    {
+        if (!skipPop)
+        {
+            if (!transactions_.try_pop(curTransaction))
+                return popCount;
+
+            canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
+            ++popCount;
+        }
+        else
+        {
+            skipPop = false;
+        }
+
+        graph_.DoTransaction([&]
+        {
+            curTransaction.func();
+
+            if (canMerge)
+            {
+                // Inner loop. Mergeable transactions are merged
+                for (;;)
+                {
+                    if (transactions_.try_pop(curTransaction))
+                        return;
+
+                    canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
+                    ++popCount;
+
+                    if (!canMerge)
+                    {
+                        skipPop = true;
+                        return;
+                    }
+
+                    curTransaction.func();
+                }
+            }
+        });
+    }
+}
+
+/****************************************/ REACT_IMPL_END /***************************************/
\ No newline at end of file
diff --git a/src/engine/PulsecountEngine.cpp b/src/engine/PulsecountEngine.cpp
index 0be62ba6..c5318fd6 100644
--- a/src/engine/PulsecountEngine.cpp
+++ b/src/engine/PulsecountEngine.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -189,12 +189,12 @@ Turn::Turn(TurnIdT id, TransactionFlagsT flags) :
 /// PulsecountEngine
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-void EngineBase::OnNodeAttach(Node& node, Node& parent)
+void EngineBase::AttachNode(Node& node, Node& parent)
 {
     parent.Successors.Add(node);
 }
 
-void EngineBase::OnNodeDetach(Node& node, Node& parent)
+void EngineBase::DetachNode(Node& node, Node& parent)
 {
     parent.Successors.Remove(node);
 }
diff --git a/src/engine/SubtreeEngine.cpp b/src/engine/SubtreeEngine.cpp
index 8584fcc2..69fb3278 100644
--- a/src/engine/SubtreeEngine.cpp
+++ b/src/engine/SubtreeEngine.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -33,7 +33,7 @@ Turn::Turn(TurnIdT id, TransactionFlagsT flags) :
 /// PulsecountEngine
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-void EngineBase::OnNodeAttach(Node& node, Node& parent)
+void EngineBase::AttachNode(Node& node, Node& parent)
 {
     parent.Successors.Add(node);
 
@@ -41,7 +41,7 @@ void EngineBase::OnNodeAttach(Node& node, Node& parent)
         node.Level = parent.Level + 1;
 }
 
-void EngineBase::OnNodeDetach(Node& node, Node& parent)
+void EngineBase::DetachNode(Node& node, Node& parent)
 {
     parent.Successors.Remove(node);
 }
@@ -230,7 +230,7 @@ void EngineBase::OnDynamicNodeAttach(Node& node, Node& parent, Turn& turn)
     }
     else
     {
-        OnNodeAttach(node, parent);
+        AttachNode(node, parent);
     
         invalidateSuccessors(node);
 
@@ -245,7 +245,7 @@ void EngineBase::OnDynamicNodeDetach(Node& node, Node& parent, Turn& turn)
     if (isInPhase2_)
         applyAsyncDynamicDetach(node, parent, turn);
     else
-        OnNodeDetach(node, parent);
+        DetachNode(node, parent);
 }
 
 void EngineBase::applyAsyncDynamicAttach(Node& node, Node& parent, Turn& turn)
diff --git a/src/engine/ToposortEngine.cpp b/src/engine/ToposortEngine.cpp
index b8db5f67..1029775f 100644
--- a/src/engine/ToposortEngine.cpp
+++ b/src/engine/ToposortEngine.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -30,7 +30,7 @@ ParTurn::ParTurn(TurnIdT id, TransactionFlagsT flags) :
 /// EngineBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename TNode, typename TTurn>
-void EngineBase<TNode,TTurn>::OnNodeAttach(TNode& node, TNode& parent)
+void EngineBase<TNode,TTurn>::AttachNode(TNode& node, TNode& parent)
 {
     parent.Successors.Add(node);
 
@@ -39,7 +39,7 @@ void EngineBase<TNode,TTurn>::OnNodeAttach(TNode& node, TNode& parent)
 }
 
 template <typename TNode, typename TTurn>
-void EngineBase<TNode,TTurn>::OnNodeDetach(TNode& node, TNode& parent)
+void EngineBase<TNode,TTurn>::DetachNode(TNode& node, TNode& parent)
 {
     parent.Successors.Remove(node);
 }
@@ -85,7 +85,7 @@ void SeqEngineBase::Propagate(SeqTurn& turn)
 
 void SeqEngineBase::OnDynamicNodeAttach(SeqNode& node, SeqNode& parent, SeqTurn& turn)
 {
-    this->OnNodeAttach(node, parent);
+    this->AttachNode(node, parent);
     
     invalidateSuccessors(node);
 
@@ -96,7 +96,7 @@ void SeqEngineBase::OnDynamicNodeAttach(SeqNode& node, SeqNode& parent, SeqTurn&
 
 void SeqEngineBase::OnDynamicNodeDetach(SeqNode& node, SeqNode& parent, SeqTurn& turn)
 {
-    this->OnNodeDetach(node, parent);
+    this->DetachNode(node, parent);
 }
 
 void SeqEngineBase::processChildren(SeqNode& node, SeqTurn& turn)
@@ -184,7 +184,7 @@ void ParEngineBase::OnDynamicNodeDetach(ParNode& node, ParNode& parent, ParTurn&
 
 void ParEngineBase::applyDynamicAttach(ParNode& node, ParNode& parent, ParTurn& turn)
 {
-    this->OnNodeAttach(node, parent);
+    this->AttachNode(node, parent);
 
     invalidateSuccessors(node);
 
@@ -195,7 +195,7 @@ void ParEngineBase::applyDynamicAttach(ParNode& node, ParNode& parent, ParTurn&
 
 void ParEngineBase::applyDynamicDetach(ParNode& node, ParNode& parent, ParTurn& turn)
 {
-    this->OnNodeDetach(node, parent);
+    this->DetachNode(node, parent);
 }
 
 void ParEngineBase::processChildren(ParNode& node, ParTurn& turn)
diff --git a/src/logging/EventLog.cpp b/src/logging/EventLog.cpp
deleted file mode 100644
index dcd8f627..00000000
--- a/src/logging/EventLog.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include "react/logging/EventLog.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-using std::chrono::duration_cast;
-using std::chrono::microseconds;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventLog
-///////////////////////////////////////////////////////////////////////////////////////////////////
-EventLog::Entry::Entry() :
-    time_{ std::chrono::system_clock::now() },
-    data_{ nullptr }
-{
-}
-
-EventLog::Entry::Entry(const Entry& other) :
-    time_{ other.time_ },
-    data_{ other.data_}
-{
-}
-
-EventLog::Entry::Entry(IEventRecord* ptr) :
-    time_{ std::chrono::system_clock::now() },
-    data_{ ptr }
-{
-}
-
-void EventLog::Entry::Serialize(std::ostream& out, const TimestampT& startTime) const
-{
-    out << EventId() << " : " << duration_cast<microseconds>(Time() - startTime).count() << std::endl;
-    data_->Serialize(out);
-}
-
-EventLog::Entry& EventLog::Entry::operator=(Entry& rhs)
-{
-    time_ = rhs.time_,
-    data_ = std::move(rhs.data_);
-    return *this;
-}
-
-bool EventLog::Entry::Equals(const Entry& other) const
-{
-    if (EventId() != other.EventId())
-        return false;
-    // Todo
-    return false;
-}
-
-EventLog::EventLog() :
-    startTime_(std::chrono::system_clock::now())
-{
-}
-
-EventLog::~EventLog()
-{
-    Clear();
-}
-
-void EventLog::Print()
-{
-    Write(std::cout);
-}
-
-void EventLog::Write(std::ostream& out)
-{
-    for (auto& e : entries_)
-        e.Serialize(out, startTime_);
-}
-
-void EventLog::Clear()
-{
-    for (auto& e : entries_)
-        e.Release();
-    entries_.clear();
-}
-
-/****************************************/ REACT_IMPL_END /***************************************/
\ No newline at end of file
diff --git a/src/logging/EventRecords.cpp b/src/logging/EventRecords.cpp
deleted file mode 100644
index 3145c43a..00000000
--- a/src/logging/EventRecords.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include <iostream>
-#include <thread>
-
-#include "react/logging/EventRecords.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeCreateEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeCreateEvent::NodeCreateEvent(ObjectId nodeId, const char* type) :
-    nodeId_( nodeId ),
-    type_( type )
-{}
-
-void NodeCreateEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Type = " << type_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeDestroyEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeDestroyEvent::NodeDestroyEvent(ObjectId nodeId) :
-    nodeId_( nodeId )
-{}
-
-void NodeDestroyEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeAttachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeAttachEvent::NodeAttachEvent(ObjectId nodeId, ObjectId parentId) :
-    nodeId_( nodeId ),
-    parentId_{ parentId }
-{}
-
-void NodeAttachEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Parent = " << parentId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeDetachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeDetachEvent::NodeDetachEvent(ObjectId nodeId, ObjectId parentId) :
-    nodeId_( nodeId ),
-    parentId_{ parentId }
-{}
-
-void NodeDetachEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Parent = " << parentId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// InputNodeAdmissionEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-InputNodeAdmissionEvent::InputNodeAdmissionEvent(ObjectId nodeId, int transactionId) :
-    nodeId_( nodeId ),
-    transactionId_( transactionId )
-{}
-
-void InputNodeAdmissionEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodePulseEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodePulseEvent::NodePulseEvent(ObjectId nodeId, int transactionId) :
-    nodeId_( nodeId ),
-    transactionId_( transactionId )
-{}
-
-void NodePulseEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeIdlePulseEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeIdlePulseEvent::NodeIdlePulseEvent(ObjectId nodeId, int transactionId) :
-    nodeId_( nodeId ),
-    transactionId_( transactionId )
-{}
-
-void NodeIdlePulseEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DynamicNodeAttachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-DynamicNodeAttachEvent::DynamicNodeAttachEvent(ObjectId nodeId, ObjectId parentId, int transactionId) :
-    nodeId_( nodeId ),
-    parentId_{ parentId },
-    transactionId_( transactionId )
-{}
-
-void DynamicNodeAttachEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Parent = " << parentId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DynamicNodeDetachEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-DynamicNodeDetachEvent::DynamicNodeDetachEvent(ObjectId nodeId, ObjectId parentId, int transactionId) :
-    nodeId_( nodeId ),
-    parentId_{ parentId },
-    transactionId_( transactionId )
-{}
-
-void DynamicNodeDetachEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Parent = " << parentId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeEvaluateBeginEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeEvaluateBeginEvent::NodeEvaluateBeginEvent(ObjectId nodeId, int transactionId) :
-    nodeId_( nodeId ),
-    transactionId_( transactionId ),
-    threadId_( std::this_thread::get_id() )
-{}
-
-void NodeEvaluateBeginEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-    out << "> Thread = " << threadId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// NodeEvaluateEndEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-NodeEvaluateEndEvent::NodeEvaluateEndEvent(ObjectId nodeId, int transactionId) :
-    nodeId_( nodeId ),
-    transactionId_( transactionId ),
-    threadId_{ std::this_thread::get_id() }
-{}
-
-void NodeEvaluateEndEvent::Serialize(std::ostream& out) const
-{
-    out << "> Node = " << nodeId_ << std::endl;
-    out << "> Transaction = " << transactionId_ << std::endl;
-    out << "> Thread = " << threadId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TransactionBeginEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TransactionBeginEvent::TransactionBeginEvent(int transactionId) :
-    transactionId_( transactionId )
-{}
-
-void TransactionBeginEvent::Serialize(std::ostream& out) const
-{
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TransactionEndEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TransactionEndEvent::TransactionEndEvent(int transactionId) :
-    transactionId_( transactionId )
-{}
-
-void TransactionEndEvent::Serialize(std::ostream& out) const
-{
-    out << "> Transaction = " << transactionId_ << std::endl;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// UserBreakpointEvent
-///////////////////////////////////////////////////////////////////////////////////////////////////
-UserBreakpointEvent::UserBreakpointEvent(const char* name) :
-    name_( name )
-{}
-
-void UserBreakpointEvent::Serialize(std::ostream& out) const
-{
-    out << "> Name = " << name_ << std::endl;
-}
-
-/****************************************/ REACT_IMPL_END /***************************************/
\ No newline at end of file
diff --git a/tests/src/EventStreamTest.cpp b/tests/src/EventStreamTest.cpp
deleted file mode 100644
index 6801c5e9..00000000
--- a/tests/src/EventStreamTest.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include "EventStreamTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-using P1 = DomainParams<sequential,ToposortEngine>;
-using P2 = DomainParams<parallel,ToposortEngine>;
-using P3 = DomainParams<parallel,PulsecountEngine>;
-using P4 = DomainParams<parallel,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposort, EventStreamTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposort, EventStreamTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(Pulsecount, EventStreamTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(Subtree, EventStreamTest, P4);
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/EventStreamTest.h b/tests/src/EventStreamTest.h
index e33653a0..db12a8ea 100644
--- a/tests/src/EventStreamTest.h
+++ b/tests/src/EventStreamTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/EventStreamTestQ.cpp b/tests/src/EventStreamTestQ.cpp
index d61330d1..26d07507 100644
--- a/tests/src/EventStreamTestQ.cpp
+++ b/tests/src/EventStreamTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/MoveTest.cpp b/tests/src/MoveTest.cpp
index c5963745..6054092a 100644
--- a/tests/src/MoveTest.cpp
+++ b/tests/src/MoveTest.cpp
@@ -1,21 +1,12 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#include "MoveTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/ToposortEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
-
-using P1 = DomainParams<sequential,ToposortEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposort, MoveTest, P1);
 
 } // ~namespace
\ No newline at end of file
diff --git a/tests/src/MoveTest.h b/tests/src/MoveTest.h
index 41eb5810..0804423a 100644
--- a/tests/src/MoveTest.h
+++ b/tests/src/MoveTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ObserverTest.cpp b/tests/src/ObserverTest.cpp
index ae331812..6054092a 100644
--- a/tests/src/ObserverTest.cpp
+++ b/tests/src/ObserverTest.cpp
@@ -1,29 +1,12 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#include "ObserverTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
-
-using P1 = DomainParams<sequential,ToposortEngine>;
-using P2 = DomainParams<parallel,ToposortEngine>;
-using P3 = DomainParams<parallel,PulsecountEngine>;
-using P4 = DomainParams<parallel,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposort, ObserverTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposort, ObserverTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(Pulsecount, ObserverTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(Subtree, ObserverTest, P4);
 
 } // ~namespace
\ No newline at end of file
diff --git a/tests/src/ObserverTest.h b/tests/src/ObserverTest.h
index af5ac834..559c0686 100644
--- a/tests/src/ObserverTest.h
+++ b/tests/src/ObserverTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ObserverTestQ.cpp b/tests/src/ObserverTestQ.cpp
index 1e36c088..4dfe55f6 100644
--- a/tests/src/ObserverTestQ.cpp
+++ b/tests/src/ObserverTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/OperationsTest.cpp b/tests/src/OperationsTest.cpp
index cc3b576e..6054092a 100644
--- a/tests/src/OperationsTest.cpp
+++ b/tests/src/OperationsTest.cpp
@@ -1,29 +1,12 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#include "OperationsTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
-
-using P1 = DomainParams<sequential,ToposortEngine>;
-using P2 = DomainParams<parallel,ToposortEngine>;
-using P3 = DomainParams<parallel,PulsecountEngine>;
-using P4 = DomainParams<parallel,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposort, OperationsTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposort, OperationsTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(Pulsecount, OperationsTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(Subtree, OperationsTest, P4);
 
 } // ~namespace
\ No newline at end of file
diff --git a/tests/src/OperationsTest.h b/tests/src/OperationsTest.h
index 1af27694..c7fb6d3f 100644
--- a/tests/src/OperationsTest.h
+++ b/tests/src/OperationsTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/OperationsTestQ.cpp b/tests/src/OperationsTestQ.cpp
index 83e8a7ab..576c0752 100644
--- a/tests/src/OperationsTestQ.cpp
+++ b/tests/src/OperationsTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/ParallelizationTest.cpp b/tests/src/ParallelizationTest.cpp
index 9ef6d156..6054092a 100644
--- a/tests/src/ParallelizationTest.cpp
+++ b/tests/src/ParallelizationTest.cpp
@@ -1,29 +1,12 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#include "ParallelizationTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
-
-using P1 = DomainParams<sequential_concurrent,ToposortEngine>;
-using P2 = DomainParams<parallel_concurrent,ToposortEngine>;
-using P3 = DomainParams<parallel_concurrent,PulsecountEngine>;
-using P4 = DomainParams<parallel_concurrent,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposortQ, ParallelizationTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposortQ, ParallelizationTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(PulsecountQ, ParallelizationTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(SubtreeQ, ParallelizationTest, P4);
 
 } // ~namespace
\ No newline at end of file
diff --git a/tests/src/ParallelizationTest.h b/tests/src/ParallelizationTest.h
index 43a99f05..145c730c 100644
--- a/tests/src/ParallelizationTest.h
+++ b/tests/src/ParallelizationTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/SignalTest.cpp b/tests/src/SignalTest.cpp
index 44a68828..a34b7f98 100644
--- a/tests/src/SignalTest.cpp
+++ b/tests/src/SignalTest.cpp
@@ -1,29 +1,11 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#include "SignalTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
-
-using P1 = DomainParams<sequential,ToposortEngine>;
-using P2 = DomainParams<parallel,ToposortEngine>;
-using P3 = DomainParams<parallel,PulsecountEngine>;
-using P4 = DomainParams<parallel,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposort, SignalTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposort, SignalTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(Pulsecount, SignalTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(Subtree, SignalTest, P4);
-
 } // ~namespace
\ No newline at end of file
diff --git a/tests/src/SignalTest.h b/tests/src/SignalTest.h
index b20eabe8..69ae81de 100644
--- a/tests/src/SignalTest.h
+++ b/tests/src/SignalTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/SignalTestQ.cpp b/tests/src/SignalTestQ.cpp
index b6bacde1..d91875c7 100644
--- a/tests/src/SignalTestQ.cpp
+++ b/tests/src/SignalTestQ.cpp
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/TestUtil.h b/tests/src/TestUtil.h
index a6cc5306..0d7b9cb6 100644
--- a/tests/src/TestUtil.h
+++ b/tests/src/TestUtil.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/TransactionTest.cpp b/tests/src/TransactionTest.cpp
index 487f7f5b..6054092a 100644
--- a/tests/src/TransactionTest.cpp
+++ b/tests/src/TransactionTest.cpp
@@ -1,29 +1,12 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#include "TransactionTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
-using namespace react;
-
-using P1 = DomainParams<sequential_concurrent,ToposortEngine>;
-using P2 = DomainParams<parallel_concurrent,ToposortEngine>;
-using P3 = DomainParams<parallel_concurrent,PulsecountEngine>;
-using P4 = DomainParams<parallel_concurrent,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposort, TransactionTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposort, TransactionTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(Pulsecount, TransactionTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(Subtree, TransactionTest, P4);
 
 } // ~namespace
\ No newline at end of file
diff --git a/tests/src/TransactionTest.h b/tests/src/TransactionTest.h
index a332de90..0501a81c 100644
--- a/tests/src/TransactionTest.h
+++ b/tests/src/TransactionTest.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/tests/src/common_tests.cpp b/tests/src/common_tests.cpp
new file mode 100644
index 00000000..0bd5b6dc
--- /dev/null
+++ b/tests/src/common_tests.cpp
@@ -0,0 +1,132 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include "gtest/gtest.h"
+
+#include "react/common/syncpoint.h"
+
+#include <chrono>
+#include <cstdio>
+#include <thread>
+
+using namespace react;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+TEST(SyncPointTest, SingleWait)
+{
+    SyncPoint sp;
+
+    SyncPoint::Dependency dep(sp);
+
+    int output = 0;
+
+    std::thread t1([storedDep = std::move(dep), &output] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+            output = 1;
+        });
+
+    
+    sp.Wait();
+    
+    EXPECT_EQ(1, output);
+
+    t1.join();
+}
+
+TEST(SyncPointTest, MultiWait)
+{
+    SyncPoint sp;
+
+    SyncPoint::Dependency dep1(sp);
+    SyncPoint::Dependency dep2(sp);
+    SyncPoint::Dependency dep3(sp);
+
+    int output1 = 0;
+    int output2 = 0;
+    int output3 = 0;
+
+    std::thread t1([storedDep = std::move(dep1), &output1] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+            output1 = 1;
+        });
+
+    std::thread t2([storedDep = std::move(dep2), &output2] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+            output2 = 2;
+        });
+
+    std::thread t3([storedDep = std::move(dep3), &output3] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+            output3 = 3;
+        });
+
+    
+    sp.Wait();
+    
+    EXPECT_EQ(1, output1);
+    EXPECT_EQ(2, output2);
+    EXPECT_EQ(3, output3);
+
+    t1.join();
+    t2.join();
+    t3.join();
+}
+
+TEST(SyncPointTest, MultiWaitFor)
+{
+    SyncPoint sp;
+
+    SyncPoint::Dependency dep1(sp);
+    SyncPoint::Dependency dep2(sp);
+    SyncPoint::Dependency dep3(sp);
+
+    int output1 = 0;
+    int output2 = 0;
+    int output3 = 0;
+
+    std::thread t1([storedDep = std::move(dep1), &output1] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(3));
+            output1 = 1;
+        });
+
+    std::thread t2([storedDep = std::move(dep2), &output2] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(3));
+            output2 = 2;
+        });
+
+    std::thread t3([storedDep = std::move(dep3), &output3] ()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(3));
+            output3 = 3;
+        });
+
+    
+    bool done = sp.WaitFor(std::chrono::milliseconds(1));
+    
+    EXPECT_FALSE(done);
+
+    EXPECT_EQ(0, output1);
+    EXPECT_EQ(0, output2);
+    EXPECT_EQ(0, output3);
+
+    done = sp.WaitFor(std::chrono::seconds(10));
+
+    EXPECT_TRUE(done);
+
+    EXPECT_EQ(1, output1);
+    EXPECT_EQ(2, output2);
+    EXPECT_EQ(3, output3);
+
+    t1.join();
+    t2.join();
+    t3.join();
+}
\ No newline at end of file
diff --git a/tests/src/event_tests.cpp b/tests/src/event_tests.cpp
new file mode 100644
index 00000000..4204a466
--- /dev/null
+++ b/tests/src/event_tests.cpp
@@ -0,0 +1,219 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include "gtest/gtest.h"
+
+#include "react/event.h"
+#include "react/observer.h"
+
+#include <thread>
+#include <chrono>
+
+using namespace react;
+
+TEST(EventTest, Construction)
+{
+    Group g;
+
+    // Event source
+    {
+        EventSource<int> t1( g );
+        EventSource<int> t2( t1 );
+        EventSource<int> t3( std::move(t1) );
+        
+        EventSource<int> ref1( t2 );
+        Event<int>       ref2( t3 );
+
+        EXPECT_TRUE(ref1 == ref2);
+    }
+
+    // Event slot
+    {
+        EventSlot<int> t1( g );
+        EventSlot<int> t2( t1 );
+        EventSlot<int> t3( std::move(t1) );
+        
+        EventSlot<int> ref1( t2 );
+        Event<int>     ref2( t3 );
+
+        EXPECT_TRUE(ref1 == ref2);
+    }
+
+    // Event link
+    {
+        EventSlot<int> s1( g );
+
+        EventLink<int> t1( g, s1 );
+        EventLink<int> t2( t1 );
+        EventLink<int> t3( std::move(t1) );
+        
+        EventLink<int> ref1( t2 );
+        Event<int>     ref2( t3 );
+
+        EXPECT_TRUE(ref1 == ref2);
+    }
+}
+
+TEST(EventTest, BasicOutput)
+{
+    Group g;
+
+    EventSource<int> evt( g );
+
+    int output = 0;
+
+    Observer obs([&] (const auto& events)
+        {
+            for (int e : events)
+                output += e;
+        }, evt);
+
+    EXPECT_EQ(0, output);
+
+    evt.Emit(1);
+    EXPECT_EQ(1, output);
+
+    evt.Emit(2);
+    EXPECT_EQ(3, output);
+}
+
+TEST(EventTest, EventSlots)
+{
+    Group g;
+
+    EventSource<int> evt1( g );
+    EventSource<int> evt2( g );
+
+    EventSlot<int> slot( g );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& events)
+        {
+            ++turns;
+
+            for (int e : events)
+                output += e;
+        }, slot);
+
+    EXPECT_EQ(0, output);
+    EXPECT_EQ(0, turns);
+
+    slot.Add(evt1);
+    slot.Add(evt2);
+
+    evt1.Emit(5);
+    evt2.Emit(2);
+
+    EXPECT_EQ(7, output);
+    EXPECT_EQ(2, turns);
+
+    output = 0;
+
+    slot.Remove(evt1);
+
+    evt1.Emit(5);
+    evt2.Emit(2);
+
+    EXPECT_EQ(2, output);
+    EXPECT_EQ(3, turns);
+
+    output = 0;
+
+    slot.Remove(evt2);
+
+    evt1.Emit(5);
+    evt2.Emit(2);
+
+    EXPECT_EQ(0, output);
+    EXPECT_EQ(3, turns);
+
+    output = 0;
+
+    slot.Add(evt1);
+    slot.Add(evt1);
+
+    evt1.Emit(5);
+    evt2.Emit(2);
+
+    EXPECT_EQ(5, output);
+    EXPECT_EQ(4, turns);
+}
+
+TEST(EventTest, EventTransactions)
+{
+    Group g;
+
+    EventSource<int> evt( g );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& events)
+        {
+            ++turns;
+            for (int e : events)
+                output += e;
+        }, evt);
+
+    EXPECT_EQ(0, output);
+
+    g.DoTransaction([&]
+        {
+            evt.Emit(1);
+            evt.Emit(1);
+            evt.Emit(1);
+            evt.Emit(1);
+        });
+
+    EXPECT_EQ(4, output);
+    EXPECT_EQ(1, turns);
+}
+
+TEST(EventTest, ExplicitEventLinks)
+{
+    Group g1;
+    Group g2;
+    Group g3;
+
+    EventSource<int> evt1( g1 );
+    EventSource<int> evt2( g2 );
+    EventSource<int> evt3( g3 );
+
+    EventSlot<int> slot( g1 );
+
+    // Same group
+    slot.Add(evt1);
+
+    // Explicit link
+    EventLink<int> lnk2( g1, evt2 );
+    slot.Add(lnk2);
+
+    // Implicit link
+    slot.Add(evt3);
+
+    int output = 0;
+    int turns = 0;
+
+    EXPECT_EQ(0, output);
+
+    Observer obs([&] (const auto& events)
+        {
+            ++turns;
+            for (int e : events)
+                output += e;
+        }, slot);
+
+    evt1.Emit(1);
+    evt2.Emit(1);
+    evt3.Emit(1);
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    EXPECT_EQ(3, output);
+    EXPECT_EQ(3, turns);
+}
\ No newline at end of file

From 63488198260b1f9c75ff8c883f93fe843459a7a6 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Tue, 24 Oct 2017 22:33:52 +0200
Subject: [PATCH 53/75] Renamed Signal to State. General progress.

---
 include/react/API.h                           |  46 +--
 include/react/Algorithm.h                     |  78 +++---
 include/react/Event.h                         |  42 +--
 include/react/Observer.h                      |  61 +---
 include/react/common/slotmap.h                |   2 +-
 include/react/common/syncpoint.h              | 103 ++++---
 include/react/common/utility.h                |  28 ++
 include/react/detail/algorithm_nodes.h        |  54 ++--
 include/react/detail/event_nodes.h            |  80 +++---
 include/react/detail/graph_impl.h             |  37 ++-
 include/react/detail/observer_nodes.h         |  66 ++++-
 .../detail/{signal_nodes.h => state_nodes.h}  | 121 ++++----
 include/react/{Signal.h => state.h}           | 162 +++++------
 project/msvc/CppReact.vcxproj                 |   6 +-
 project/msvc/CppReact.vcxproj.filters         |  12 +-
 project/msvc/CppReactTest.vcxproj             |   4 +-
 project/msvc/CppReactTest.vcxproj.filters     |  10 +-
 src/detail/graph_impl.cpp                     |  49 +++-
 tests/src/SignalTest.cpp                      |  11 -
 tests/src/TransactionTest.cpp                 |  12 -
 tests/src/common_tests.cpp                    |  31 ++-
 tests/src/event_tests.cpp                     |   6 +-
 tests/src/state_tests.cpp                     | 262 ++++++++++++++++++
 tests/src/transaction_tests.cpp               | 220 +++++++++++++++
 24 files changed, 1031 insertions(+), 472 deletions(-)
 rename include/react/detail/{signal_nodes.h => state_nodes.h} (75%)
 rename include/react/{Signal.h => state.h} (51%)
 delete mode 100644 tests/src/SignalTest.cpp
 delete mode 100644 tests/src/TransactionTest.cpp
 create mode 100644 tests/src/state_tests.cpp
 create mode 100644 tests/src/transaction_tests.cpp

diff --git a/include/react/API.h b/include/react/API.h
index 3e20d5bb..89ace35c 100644
--- a/include/react/API.h
+++ b/include/react/API.h
@@ -37,23 +37,23 @@ REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
 /// API types
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-// Groups
+// Group
 class Group;
 
-// Signals
+// State
 template <typename S>
-class Signal;
+class State;
 
 template <typename S>
-class VarSignal;
+class StateVar;
 
 template <typename S>
-class SignalSlot;
+class StateSlot;
 
 template <typename S>
-class SignalLink;
+class StateLink;
 
-// Events
+// Event
 enum class Token;
 
 template <typename E = Token>
@@ -65,39 +65,9 @@ class EventSource;
 template <typename E>
 class EventSlot;
 
-// Observers
+// Observer
 class Observer;
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Traits
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct IsSignal { static const bool value = false; };
-
-template <typename T>
-struct IsSignal<Signal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsSignal<VarSignal<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsEvent { static const bool value = false; };
-
-template <typename T>
-struct IsEvent<Event<T>> { static const bool value = true; };
-
-template <typename T>
-struct IsEvent<EventSource<T>> { static const bool value = true; };
-
-template <typename T>
-struct AsNonInputNode { using type = T; };
-
-template <typename T>
-struct AsNonInputNode<VarSignal<T>> { using type = Signal<T>; };
-
-template <typename T>
-struct AsNonInputNode<EventSource<T>> { using type = Event<T>; };
-
 /******************************************/ REACT_END /******************************************/
 
 #endif // REACT_TYPETRAITS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Algorithm.h b/include/react/Algorithm.h
index e149b491..9c1b2023 100644
--- a/include/react/Algorithm.h
+++ b/include/react/Algorithm.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
@@ -18,52 +18,52 @@
 #include "react/API.h"
 #include "react/detail/algorithm_nodes.h"
 
+#include "react/state.h"
 #include "react/event.h"
-#include "react/signal.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Hold the most recent event in a signal
+/// Hold the most recent event in a state
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, typename E>
-auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> Signal<E>
+auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> State<E>
 {
     using REACT_IMPL::HoldNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
-    return CreateWrappedNode<Signal<E>, HoldNode<E>>(
+    return CreateWrappedNode<State<E>, HoldNode<E>>(
         group, std::forward<T>(initialValue), SameGroupOrLink(group, evnt));
 }
 
 template <typename T, typename E>
-auto Hold(T&& initialValue, const Event<E>& evnt) -> Signal<E>
+auto Hold(T&& initialValue, const Event<E>& evnt) -> State<E>
     { return Hold(evnt.GetGroup(), std::forward<T>(initialValue), evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Emits value changes of target signal.
+/// Emits value changes of target state.
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-auto Monitor(const Group& group, const Signal<S>& signal) -> Event<S>
+auto Monitor(const Group& group, const State<S>& state) -> Event<S>
 {
     using REACT_IMPL::MonitorNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
     return CreateWrappedNode<Event<S>, MonitorNode<S>>(
-        group, SameGroupOrLink(group, signal));
+        group, SameGroupOrLink(group, state));
 }
 
 template <typename S>
-auto Monitor(const Signal<S>& signal) -> Event<S>
-    { return Monitor(signal.GetGroup(), signal); }
+auto Monitor(const State<S>& state) -> Event<S>
+    { return Monitor(state.GetGroup(), state); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate - Iteratively combines signal value with values from event stream (aka Fold)
+/// Iterate - Iteratively combines state value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E>
-auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
 {
     using REACT_IMPL::IterateNode;
     using REACT_IMPL::IsCallableWith;
@@ -72,12 +72,12 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
 
     using FuncType = typename std::decay<F>::type;
 
-    return CreateWrappedNode<Signal<S>, IterateNode<S, FuncType, E>>(
+    return CreateWrappedNode<State<S>, IterateNode<S, FuncType, E>>(
         group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename T, typename F, typename E>
-auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
 {
     using REACT_IMPL::IterateByRefNode;
     using REACT_IMPL::IsCallableWith;
@@ -86,23 +86,23 @@ auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>
 
     using FuncType = typename std::decay<F>::type;
 
-    return CreateWrappedNode<Signal<S>, IterateByRefNode<S, FuncType, E>>(
+    return CreateWrappedNode<State<S>, IterateByRefNode<S, FuncType, E>>(
         group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename T, typename F, typename E>
-auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
     { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt); }
 
 template <typename S, typename T, typename F, typename E>
-auto IterateByRef(T&& initialValue, F&& func, const Event<E>& evnt) -> Signal<S>
+auto IterateByRef(T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
     { return IterateByRef<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterate - Synced
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
+auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const State<Us>& ... states) -> State<S>
 {
     using REACT_IMPL::SyncedIterateNode;
     using REACT_IMPL::IsCallableWith;
@@ -111,12 +111,12 @@ auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evn
 
     using FuncType = typename std::decay<F>::type;
 
-    return CreateWrappedNode<Signal<S>, SyncedIterateNode<S, FuncType, E, Us ...>>(
-        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, signals) ...);
+    return CreateWrappedNode<State<S>, SyncedIterateNode<S, FuncType, E, Us ...>>(
+        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, states) ...);
 }
 
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
+auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const State<Us>& ... states) -> State<S>
 {
     using REACT_IMPL::SyncedIterateByRefNode;
     using REACT_IMPL::IsCallableWith;
@@ -125,53 +125,53 @@ auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>
 
     using FuncType = typename std::decay<F>::type;
 
-    return CreateWrappedNode<Signal<S>, SyncedIterateByRefNode<S, FuncType, E, Us ...>>(
-        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, signals) ...);
+    return CreateWrappedNode<State<S>, SyncedIterateByRefNode<S, FuncType, E, Us ...>>(
+        group, std::forward<T>(initialValue), std::forward<F>(func), SameGroupOrLink(group, evnt), SameGroupOrLink(group, states) ...);
 }
 
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
-    { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, signals ...); }
+auto Iterate(T&& initialValue, F&& func, const Event<E>& evnt, const State<Us>& ... states) -> State<S>
+    { return Iterate<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, states ...); }
 
 template <typename S, typename T, typename F, typename E, typename ... Us>
-auto IterateByRef(T&& initialValue, F&& func, const Event<E>& evnt, const Signal<Us>& ... signals) -> Signal<S>
-    { return IterateByRef<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, signals ...); }
+auto IterateByRef(T&& initialValue, F&& func, const Event<E>& evnt, const State<Us>& ... states) -> State<S>
+    { return IterateByRef<S>(evnt.GetGroup(), std::forward<T>(initialValue), std::forward<F>(func), evnt, states ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Snapshot - Sets signal value to value of other signal when event is received
+/// Snapshot - Sets state value to value of other state when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Snapshot(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
+auto Snapshot(const Group& group, const State<S>& state, const Event<E>& evnt) -> State<S>
 {
     using REACT_IMPL::SnapshotNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
-    return CreateWrappedNode<Signal<S>, SnapshotNode<S, E>>(
-        group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
+    return CreateWrappedNode<State<S>, SnapshotNode<S, E>>(
+        group, SameGroupOrLink(group, state), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename E>
-auto Snapshot(const Signal<S>& signal, const Event<E>& evnt) -> Signal<S>
-    { return Snapshot(signal.GetGroup(), signal, evnt); }
+auto Snapshot(const State<S>& state, const Event<E>& evnt) -> State<S>
+    { return Snapshot(state.GetGroup(), state, evnt); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Pulse - Emits value of target signal when event is received
+/// Pulse - Emits value of target state when event is received
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-auto Pulse(const Group& group, const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
+auto Pulse(const Group& group, const State<S>& state, const Event<E>& evnt) -> Event<S>
 {
     using REACT_IMPL::PulseNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
     return CreateWrappedNode<Event<S>, PulseNode<S, E>>(
-        group, SameGroupOrLink(group, signal), SameGroupOrLink(group, evnt));
+        group, SameGroupOrLink(group, state), SameGroupOrLink(group, evnt));
 }
 
 template <typename S, typename E>
-auto Pulse(const Signal<S>& signal, const Event<E>& evnt) -> Event<S>
-    { return Pulse(signal.GetGroup(), signal, evnt); }
+auto Pulse(const State<S>& state, const Event<E>& evnt) -> Event<S>
+    { return Pulse(state.GetGroup(), state, evnt); }
 
 /******************************************/ REACT_END /******************************************/
 
diff --git a/include/react/Event.h b/include/react/Event.h
index ff4a0a17..903d3dc6 100644
--- a/include/react/Event.h
+++ b/include/react/Event.h
@@ -51,14 +51,14 @@ class Event : protected REACT_IMPL::EventInternals<E>
 
     // Construct with explicit group
     template <typename F, typename T, typename ... Us>
-    Event(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( CreateSyncedProcessingNode(group, std::forward<F>(func), dep, signals ...) )
+    Event(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... states) :
+        Event::Event( CreateSyncedProcessingNode(group, std::forward<F>(func), dep, states ...) )
     { }
 
     // Construct with implicit group
     template <typename F, typename T, typename ... Us>
-    Event(F&& func, const Event<T>& dep, const Signal<Us>& ... signals) :
-        Event::Event( CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, signals ...) )
+    Event(F&& func, const Event<T>& dep, const State<Us>& ... states) :
+        Event::Event( CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, states ...) )
     { }
 
     auto Tokenize() const -> decltype(auto)
@@ -84,7 +84,7 @@ class Event : protected REACT_IMPL::EventInternals<E>
 
 protected:
     // Private node ctor
-    explicit Event(std::shared_ptr<REACT_IMPL::EventStreamNode<E>>&& nodePtr) :
+    explicit Event(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
         Event::EventInternals( std::move(nodePtr) )
     { }
 
@@ -99,7 +99,7 @@ class Event : protected REACT_IMPL::EventInternals<E>
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedProcessingNode(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedProcessingNode(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::SyncedEventProcessingNode;
         using REACT_IMPL::SameGroupOrLink;
@@ -166,7 +166,7 @@ class EventSource : public Event<E>
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<T>(value)); });
+        graphPtr->PushInput(nodeId, [castedPtr, &value] { castedPtr->EmitValue(std::forward<T>(value)); });
     }
 };
 
@@ -215,7 +215,7 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [this, castedPtr, &input] { castedPtr->AddInput(SameGroupOrLink(GetGroup(), input)); });
+        graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->AddInput(SameGroupOrLink(GetGroup(), input)); });
     }
 
     void RemoveInput(const Event<E>& input)
@@ -228,7 +228,7 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [this, castedPtr, &input] { castedPtr->RemoveInput(SameGroupOrLink(GetGroup(), input)); });
+        graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->RemoveInput(SameGroupOrLink(GetGroup(), input)); });
     }
 
     void RemoveAllInputs()
@@ -241,7 +241,7 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr] { castedPtr->RemoveAllInputs(); });
+        graphPtr->PushInput(nodeId, [castedPtr] { castedPtr->RemoveAllInputs(); });
     }
 };
 
@@ -309,8 +309,8 @@ auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 template <typename F, typename E>
 auto Filter(const Group& group, F&& pred, const Event<E>& dep) -> Event<E>
 {
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out)
-        { std::copy_if(inRange.begin(), inRange.end(), out, capturedPred); };
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out)
+        { std::copy_if(evts.begin(), evts.end(), out, capturedPred); };
 
     return Event<E>(group, std::move(filterFunc), dep);
 }
@@ -320,20 +320,20 @@ auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
     { return Filter(dep.GetGroup(), std::forward<F>(pred), dep); }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(const Group& group, F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
+auto Filter(const Group& group, F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
 {
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (EventRange<E> inRange, EventSink<E> out, const Us& ... values)
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out, const Us& ... values)
     {
-        for (const auto& v : inRange)
+        for (const auto& v : evts)
             if (capturedPred(v, values ...))
                 *out++ = v;
     };
 
-    return Event<E>(group, std::move(filterFunc), dep, signals ...);
+    return Event<E>(group, std::move(filterFunc), dep, State ...);
 }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(F&& pred, const Event<E>& dep, const Signal<Ts>& ... signals) -> Event<E>
+auto Filter(F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
     { return Filter(dep.GetGroup(), std::forward<F>(pred), dep); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -353,7 +353,7 @@ auto Transform(F&& op, const Event<T>& dep) -> Event<E>
     { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep); }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
+auto Transform(const Group& group, F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
     {
@@ -361,12 +361,12 @@ auto Transform(const Group& group, F&& op, const Event<T>& dep, const Signal<Us>
             *out++ = capturedPred(v, values ...);
     };
 
-    return Event<E>(group, std::move(transformFunc), dep, signals ...);
+    return Event<E>(group, std::move(transformFunc), dep, states ...);
 }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(F&& op, const Event<T>& dep, const Signal<Us>& ... signals) -> Event<E>
-    { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep, signals ...); }
+auto Transform(F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
+    { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep, states ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Join
diff --git a/include/react/Observer.h b/include/react/Observer.h
index 1f28136d..3f228ffd 100644
--- a/include/react/Observer.h
+++ b/include/react/Observer.h
@@ -18,39 +18,6 @@
 
 #include "react/detail/observer_nodes.h"
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-class ObserverInternals
-{
-public:
-    ObserverInternals(const ObserverInternals&) = default;
-    ObserverInternals& operator=(const ObserverInternals&) = default;
-
-    ObserverInternals(ObserverInternals&&) = default;
-    ObserverInternals& operator=(ObserverInternals&&) = default;
-
-    explicit ObserverInternals(std::shared_ptr<ObserverNode>&& nodePtr) :
-        nodePtr_( std::move(nodePtr) )
-    { }
-
-    auto GetNodePtr() -> std::shared_ptr<ObserverNode>&
-        { return nodePtr_; }
-
-    auto GetNodePtr() const -> const std::shared_ptr<ObserverNode>&
-        { return nodePtr_; }
-
-    NodeId GetNodeId() const
-        { return nodePtr_->GetNodeId(); }
-
-protected:
-    ObserverInternals() = default;
-
-private:
-    std::shared_ptr<ObserverNode> nodePtr_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -68,16 +35,16 @@ class Observer : protected REACT_IMPL::ObserverInternals
     Observer(Observer&&) = default;
     Observer& operator=(Observer&&) = default;
 
-    // Construct signal observer with explicit group
+    // Construct state observer with explicit group
     template <typename F, typename T1, typename ... Ts>
-    Observer(const Group& group, F&& func, const Signal<T1>& subject1, const Signal<Ts>& ... subjects) :
-        Observer::Observer( CreateSignalObserverNode(group, std::forward<F>(func), subject1, subjects ...))
+    Observer(const Group& group, F&& func, const State<T1>& subject1, const State<Ts>& ... subjects) :
+        Observer::Observer( CreateStateObserverNode(group, std::forward<F>(func), subject1, subjects ...))
     { }
 
-    // Construct signal observer with implicit group
+    // Construct state observer with implicit group
     template <typename F, typename T1, typename ... Ts>
-    Observer(F&& func, const Signal<T1>& subject1, const Signal<Ts>& ... subjects) :
-        Observer::Observer( CreateSignalObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...))
+    Observer(F&& func, const State<T1>& subject1, const State<Ts>& ... subjects) :
+        Observer::Observer( CreateStateObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...))
     { }
 
     // Construct event observer with explicit group
@@ -94,14 +61,14 @@ class Observer : protected REACT_IMPL::ObserverInternals
 
     // Constructed synced event observer with explicit group
     template <typename F, typename T, typename ... Us>
-    Observer(const Group& group, F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer( CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, signals ...))
+    Observer(const Group& group, F&& func, const Event<T>& subject, const State<Us>& ... states) :
+        Observer::Observer( CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, states ...))
     { }
 
     // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
-    Observer(F&& func, const Event<T>& subject, const Signal<Us>& ... signals) :
-        Observer::Observer( CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, signals ...))
+    Observer(F&& func, const Event<T>& subject, const State<Us>& ... states) :
+        Observer::Observer( CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, states ...))
     { }
 
 public: //Internal
@@ -112,10 +79,10 @@ class Observer : protected REACT_IMPL::ObserverInternals
 
 protected:
     template <typename F, typename T1, typename ... Ts>
-    auto CreateSignalObserverNode(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
+    auto CreateStateObserverNode(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::SignalObserverNode;
-        return std::make_shared<SignalObserverNode<typename std::decay<F>::type, T1, Ts ...>>(
+        using REACT_IMPL::StateObserverNode;
+        return std::make_shared<StateObserverNode<typename std::decay<F>::type, T1, Ts ...>>(
             group, std::forward<F>(func), SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
     }
 
@@ -128,7 +95,7 @@ class Observer : protected REACT_IMPL::ObserverInternals
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(const Group& group, F&& func, const Event<T>& dep, const Signal<Us>& ... syncs) -> decltype(auto)
+    auto CreateSyncedEventObserverNode(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::SyncedEventObserverNode;
         return std::make_shared<SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>>(
diff --git a/include/react/common/slotmap.h b/include/react/common/slotmap.h
index c0282ec0..b5b51e21 100644
--- a/include/react/common/slotmap.h
+++ b/include/react/common/slotmap.h
@@ -1,5 +1,5 @@
 
-//          Copyright Sebastian Jeckel 2016.
+//          Copyright Sebastian Jeckel 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
diff --git a/include/react/common/syncpoint.h b/include/react/common/syncpoint.h
index 7ca5586b..b4fc73f8 100644
--- a/include/react/common/syncpoint.h
+++ b/include/react/common/syncpoint.h
@@ -11,8 +11,10 @@
 
 #include "react/detail/defs.h"
 
+#include <algorithm>
 #include <chrono>
 #include <condition_variable>
+#include <iterator>
 #include <mutex>
 
 
@@ -23,20 +25,23 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 class SyncPoint
 {
-private:
+public:
     class Dependency;
 
-    class ISyncPointState
+private:
+    
+
+    class ISyncTarget
     {
     public:
-        virtual ~ISyncPointState() = default;
+        virtual ~ISyncTarget() = default;
 
         virtual void IncrementWaitCount() = 0;
         
         virtual void DecrementWaitCount() = 0;
     };
 
-    class SyncPointState : public ISyncPointState
+    class SyncPointState : public ISyncTarget
     {
     public:
         virtual void IncrementWaitCount() override
@@ -81,14 +86,27 @@ class SyncPoint
         int waitCount_ = 0;
     };
 
-    class SyncPointStateCollection : public ISyncPointState
+    class SyncTargetCollection : public ISyncTarget
     {
-    private:
-        std::vector<Dependency>
+    public:
+        virtual void IncrementWaitCount() override
+        {
+            for (const auto& e : targets)
+                e->IncrementWaitCount();
+        }
+
+        virtual void DecrementWaitCount() override
+        {
+            for (const auto& e : targets)
+                e->DecrementWaitCount();
+        }
+
+        std::vector<std::shared_ptr<ISyncTarget>> targets;
     };
 
 public:
-    SyncPoint() : state_( std::make_shared<SyncPointState>() )
+    SyncPoint() :
+        state_( std::make_shared<SyncPointState>() )
     { }
 
     SyncPoint(const SyncPoint&) = default;
@@ -123,67 +141,90 @@ class SyncPoint
 
         // Construct from single sync point.
         explicit Dependency(const SyncPoint& sp) :
-            state_( sp.state_ )
+            target_( sp.state_ )
         {
-            state_->IncrementWaitCount();
+            target_->IncrementWaitCount();
         }
 
         // Construct from vector of other dependencies.
-        explicit Dependency(std::vector<Dependency>&& others) :
-            state_( sp.state_ )
+        template <typename TBegin, typename TEnd>
+        Dependency(TBegin first, TEnd last)
         {
-            state_->IncrementWaitCount();
+            auto count = std::distance(first, last);
+
+            if (count == 1)
+            {
+                target_ = first->target_;
+                if (target_)
+                    target_->IncrementWaitCount();
+            }
+            else if (count > 1)
+            {
+                auto collection = std::make_shared<SyncTargetCollection>();
+                collection->targets.reserve(count);
+            
+                for (; !(first == last); ++first)
+                    if (first->target_) // There's no point in propagating released/empty dependencies.
+                        collection->targets.push_back(first->target_);
+
+                collection->IncrementWaitCount();
+
+                target_ = std::move(collection);
+            }
         }
 
         Dependency(const Dependency& other) :
-            state_( other.state_ )
+            target_( other.target_ )
         {
-            state_->IncrementWaitCount();
+            if (target_)
+                target_->IncrementWaitCount();
         }
 
         Dependency& operator=(const Dependency& other)
         {
-            if (other.state_)
-                state_->IncrementWaitCount();
+            if (other.target_)
+                other.target_->IncrementWaitCount();
 
-            if (state_)
-                state_->DecrementWaitCount();
+            if (target_)
+                target_->DecrementWaitCount();
 
-            state_ = other.state_;
+            target_ = other.target_;
+            return *this;
         }
 
         Dependency(Dependency&& other) :
-            state_( std::move(other.state_) )
+            target_( std::move(other.target_) )
         { }
 
         Dependency& operator=(Dependency&& other)
         {
-            if (state_)
-                state_->DecrementWaitCount();
+            if (target_)
+                target_->DecrementWaitCount();
 
-            state_ = std::move(other.state_);
+            target_ = std::move(other.target_);
+            return *this;
         }
 
         ~Dependency()
         {
-            if (state_)
-                state_->DecrementWaitCount();
+            if (target_)
+                target_->DecrementWaitCount();
         }
 
         void Release()
         {
-            if (state_)
+            if (target_)
             {
-                state_->DecrementWaitCount();
-                state_.reset();
+                target_->DecrementWaitCount();
+                target_ = nullptr;
             }
         }
 
         bool IsReleased() const
-            { return state_ == nullptr; }
+            { return target_ == nullptr; }
 
     private:
-        std::shared_ptr<ISyncPointState> state_;
+        std::shared_ptr<ISyncTarget> target_;
     };
 
 private:
diff --git a/include/react/common/utility.h b/include/react/common/utility.h
index d1ce975d..8152ca3f 100644
--- a/include/react/common/utility.h
+++ b/include/react/common/utility.h
@@ -17,6 +17,34 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
+template<size_t N>
+struct Apply
+{
+    template <typename F, typename T, typename ... A>
+    static auto apply(F&& f, T&& t, A&& ... a) -> decltype(auto)
+    {
+        return Apply<N-1>::apply(std::forward<F>(f), std::forward<T>(t), std::get<N-1>(
+            std::forward<T>(t)), std::forward<A>(a)...);
+    }
+};
+
+template<>
+struct Apply<0>
+{
+    template <typename F, typename T, typename ... A>
+    static auto apply(F&& f, T&&, A&& ... a) -> decltype(auto)
+    {
+        return std::forward<F>(f)(std::forward<A>(a) ...);
+    }
+};
+
+template<typename F, typename T>
+inline auto apply(F&& f, T&& t) -> decltype(auto)
+{
+    return Apply<std::tuple_size<typename std::decay<T>::type>::value>::apply(
+        std::forward<F>(f), std::forward<T>(t));
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Helper to enable calling a function on each element of an argument pack.
 /// We can't do f(args) ...; because ... expands with a comma.
diff --git a/include/react/detail/algorithm_nodes.h b/include/react/detail/algorithm_nodes.h
index 94cdde7e..b0a7d9da 100644
--- a/include/react/detail/algorithm_nodes.h
+++ b/include/react/detail/algorithm_nodes.h
@@ -14,8 +14,8 @@
 #include <memory>
 #include <utility>
 
+#include "state_nodes.h"
 #include "event_nodes.h"
-#include "signal_nodes.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
@@ -23,12 +23,12 @@
 /// IterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename F, typename E>
-class IterateNode : public SignalNode<S>
+class IterateNode : public StateNode<S>
 {
 public:
     template <typename T, typename FIn>
     IterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt) :
-        IterateNode::SignalNode( group, std::forward<T>(init) ),
+        IterateNode::StateNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         evnt_( evnt )
     {
@@ -66,12 +66,12 @@ class IterateNode : public SignalNode<S>
 /// IterateByRefNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename F, typename E>
-class IterateByRefNode : public SignalNode<S>
+class IterateByRefNode : public StateNode<S>
 {
 public:
     template <typename T, typename FIn>
     IterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt) :
-        IterateByRefNode::SignalNode( group, std::forward<T>(init) ),
+        IterateByRefNode::StateNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         evnt_( evnt )
     {
@@ -102,12 +102,12 @@ class IterateByRefNode : public SignalNode<S>
 /// SyncedIterateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename F, typename E, typename ... TSyncs>
-class SyncedIterateNode : public SignalNode<S>
+class SyncedIterateNode : public StateNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt, const Signal<TSyncs>& ... syncs) :
-        SyncedIterateNode::SignalNode( group, std::forward<T>(init) ),
+    SyncedIterateNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt, const State<TSyncs>& ... syncs) :
+        SyncedIterateNode::StateNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         evnt_( evnt ),
         syncHolder_( syncs ... )
@@ -119,7 +119,7 @@ class SyncedIterateNode : public SignalNode<S>
 
     ~SyncedIterateNode()
     {
-        std::apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
@@ -130,7 +130,7 @@ class SyncedIterateNode : public SignalNode<S>
         if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
-        S newValue = std::apply(
+        S newValue = apply(
             [this] (const auto& ... syncs)
             {
                 return func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(syncs).Value() ...);
@@ -152,19 +152,19 @@ class SyncedIterateNode : public SignalNode<S>
     F           func_;
     Event<E>    evnt_;
 
-    std::tuple<Signal<TSyncs> ...> syncHolder_;
+    std::tuple<State<TSyncs> ...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SyncedIterateByRefNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename F, typename E, typename ... TSyncs>
-class SyncedIterateByRefNode : public SignalNode<S>
+class SyncedIterateByRefNode : public StateNode<S>
 {
 public:
     template <typename T, typename FIn>
-    SyncedIterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt, const Signal<TSyncs>& ... syncs) :
-        SyncedIterateByRefNode::SignalNode( group, std::forward<T>(init) ),
+    SyncedIterateByRefNode(const Group& group, T&& init, FIn&& func, const Event<E>& evnt, const State<TSyncs>& ... syncs) :
+        SyncedIterateByRefNode::StateNode( group, std::forward<T>(init) ),
         func_( std::forward<FIn>(func) ),
         evnt_( evnt ),
         syncHolder_( syncs ... )
@@ -176,7 +176,7 @@ class SyncedIterateByRefNode : public SignalNode<S>
 
     ~SyncedIterateByRefNode()
     {
-        std::apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
@@ -187,7 +187,7 @@ class SyncedIterateByRefNode : public SignalNode<S>
         if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
-        std::apply(
+        apply(
             [this] (const auto& ... args)
             {
                 func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(args).Value() ...);
@@ -201,19 +201,19 @@ class SyncedIterateByRefNode : public SignalNode<S>
     F           func_;
     Event<E>    events_;
 
-    std::tuple<Signal<TSyncs> ...> syncHolder_;
+    std::tuple<State<TSyncs> ...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// HoldNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class HoldNode : public SignalNode<S>
+class HoldNode : public StateNode<S>
 {
 public:
     template <typename T>
     HoldNode(const Group& group, T&& init, const Event<S>& evnt) :
-        HoldNode::SignalNode( group, std::forward<T>(init) ),
+        HoldNode::StateNode( group, std::forward<T>(init) ),
         evnt_( evnt )
     {
         this->RegisterMe();
@@ -255,11 +255,11 @@ class HoldNode : public SignalNode<S>
 /// SnapshotNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-class SnapshotNode : public SignalNode<S>
+class SnapshotNode : public StateNode<S>
 {
 public:
-    SnapshotNode(const Group& group, const Signal<S>& target, const Event<E>& trigger) :
-        SnapshotNode::SignalNode( group, GetInternals(target).Value() ),
+    SnapshotNode(const Group& group, const State<S>& target, const Event<E>& trigger) :
+        SnapshotNode::StateNode( group, GetInternals(target).Value() ),
         target_( target ),
         trigger_( trigger )
     {
@@ -297,7 +297,7 @@ class SnapshotNode : public SignalNode<S>
     }
 
 private:
-    Signal<S>   target_;
+    State<S>    target_;
     Event<E>    trigger_;
 };
 
@@ -308,7 +308,7 @@ template <typename S>
 class MonitorNode : public EventStreamNode<S>
 {
 public:
-    MonitorNode(const Group& group, const Signal<S>& target) :
+    MonitorNode(const Group& group, const State<S>& target) :
         MonitorNode::EventStreamNode( group ),
         target_( target )
     {
@@ -330,7 +330,7 @@ class MonitorNode : public EventStreamNode<S>
     }
 
 private:
-    Signal<S>    target_;
+    State<S>    target_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -340,7 +340,7 @@ template <typename S, typename E>
 class PulseNode : public EventStreamNode<S>
 {
 public:
-    PulseNode(const Group& group, const Signal<S>& target, const Event<E>& trigger) :
+    PulseNode(const Group& group, const State<S>& target, const Event<E>& trigger) :
         PulseNode::EventStreamNode( group ),
         target_( target ),
         trigger_( trigger )
@@ -373,7 +373,7 @@ class PulseNode : public EventStreamNode<S>
     }
 
 private:
-    Signal<S>   target_;
+    State<S>    target_;
     Event<E>    trigger_;
 };
 
diff --git a/include/react/detail/event_nodes.h b/include/react/detail/event_nodes.h
index 1a2e1cdf..f422a903 100644
--- a/include/react/detail/event_nodes.h
+++ b/include/react/detail/event_nodes.h
@@ -20,7 +20,7 @@
 //#include "tbb/spin_mutex.h"
 
 #include "node_base.h"
-#include "react/common/Types.h"
+#include "react/common/utility.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
@@ -41,23 +41,23 @@ using EventValueSink = std::back_insert_iterator<std::vector<E>>;
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalNode;
+class StateNode;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventStreamNode
+/// EventNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class EventStreamNode : public NodeBase
+class EventNode : public NodeBase
 {
 public:
-    EventStreamNode(EventStreamNode&&) = default;
-    EventStreamNode& operator=(EventStreamNode&&) = default;
+    EventNode(EventNode&&) = default;
+    EventNode& operator=(EventNode&&) = default;
 
-    EventStreamNode(const EventStreamNode&) = delete;
-    EventStreamNode& operator=(const EventStreamNode&) = delete;
+    EventNode(const EventNode&) = delete;
+    EventNode& operator=(const EventNode&) = delete;
 
-    explicit EventStreamNode(const Group& group) :
-        EventStreamNode::NodeBase( group )
+    explicit EventNode(const Group& group) :
+        EventNode::NodeBase( group )
     { }
 
     EventValueList<E>& Events()
@@ -77,11 +77,11 @@ class EventStreamNode : public NodeBase
 /// EventSourceNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class EventSourceNode : public EventStreamNode<E>
+class EventSourceNode : public EventNode<E>
 {
 public:
     EventSourceNode(const Group& group) :
-        EventSourceNode::EventStreamNode( group )
+        EventSourceNode::EventNode( group )
     {
         this->RegisterMe(NodeCategory::input);
     }
@@ -108,11 +108,11 @@ class EventSourceNode : public EventStreamNode<E>
 /// EventMergeNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E, typename ... TInputs>
-class EventMergeNode : public EventStreamNode<E>
+class EventMergeNode : public EventNode<E>
 {
 public:
     EventMergeNode(const Group& group, const Event<TInputs>& ... deps) :
-        EventMergeNode::EventStreamNode( group ),
+        EventMergeNode::EventNode( group ),
         inputs_( deps ... )
     {
         this->RegisterMe();
@@ -121,14 +121,14 @@ class EventMergeNode : public EventStreamNode<E>
 
     ~EventMergeNode()
     {
-        std::apply([this] (const auto& ... deps)
+        apply([this] (const auto& ... deps)
             { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        std::apply([this] (auto& ... deps)
+        apply([this] (auto& ... deps)
             { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
 
         if (! this->Events().empty())
@@ -152,11 +152,11 @@ class EventMergeNode : public EventStreamNode<E>
 /// EventSlotNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class EventSlotNode : public EventStreamNode<E>
+class EventSlotNode : public EventNode<E>
 {
 public:
     EventSlotNode(const Group& group) :
-        EventSlotNode::EventStreamNode( group )
+        EventSlotNode::EventNode( group )
     {
         inputNodeId_ = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
         this->RegisterMe();
@@ -235,12 +235,12 @@ class EventSlotNode : public EventStreamNode<E>
 /// EventProcessingNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename TOut, typename TIn, typename F>
-class EventProcessingNode : public EventStreamNode<TOut>
+class EventProcessingNode : public EventNode<TOut>
 {
 public:
     template <typename FIn>
     EventProcessingNode(const Group& group, FIn&& func, const Event<TIn>& dep) :
-        EventProcessingNode::EventStreamNode( group ),
+        EventProcessingNode::EventNode( group ),
         func_( std::forward<FIn>(func) ),
         dep_( dep )
     {
@@ -256,7 +256,7 @@ class EventProcessingNode : public EventStreamNode<TOut>
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        func_(EventRange<TIn>( GetInternals(dep_).Events() ), std::back_inserter(this->Events()));
+        func_(GetInternals(dep_).Events(), std::back_inserter(this->Events()));
 
         if (! this->Events().empty())
             return UpdateResult::changed;
@@ -274,12 +274,12 @@ class EventProcessingNode : public EventStreamNode<TOut>
 /// SyncedEventProcessingNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename TOut, typename TIn, typename F, typename ... TSyncs>
-class SyncedEventProcessingNode : public EventStreamNode<TOut>
+class SyncedEventProcessingNode : public EventNode<TOut>
 {
 public:
     template <typename FIn>
-    SyncedEventProcessingNode(const Group& group, FIn&& func, const Event<TIn>& dep, const Signal<TSyncs>& ... syncs) :
-        SyncedEventProcessingNode::EventStreamNode( group ),
+    SyncedEventProcessingNode(const Group& group, FIn&& func, const Event<TIn>& dep, const State<TSyncs>& ... syncs) :
+        SyncedEventProcessingNode::EventNode( group ),
         func_( std::forward<FIn>(func) ),
         dep_( dep ),
         syncHolder_( syncs ... )
@@ -291,7 +291,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 
     ~SyncedEventProcessingNode()
     {
-        std::apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
+        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
         this->DetachFromMe(dep_->GetNodeId());
         this->UnregisterMe();
     }
@@ -302,7 +302,7 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
         if (dep_->Events().empty())
             return UpdateResult::unchanged;
 
-        std::apply(
+        apply(
             [this] (const auto& ... syncs)
             {
                 func_(EventRange<TIn>( this->dep_->Events() ), std::back_inserter(this->Events()), syncs->Value() ...);
@@ -320,18 +320,18 @@ class SyncedEventProcessingNode : public EventStreamNode<TOut>
 
     Event<TIn> dep_;
 
-    std::tuple<Signal<TSyncs> ...> syncHolder_;
+    std::tuple<State<TSyncs> ...> syncHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// EventJoinNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename ... Ts>
-class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
+class EventJoinNode : public EventNode<std::tuple<Ts ...>>
 {
 public:
     EventJoinNode(const Group& group, const Event<Ts>& ... deps) :
-        EventJoinNode::EventStreamNode( group ),
+        EventJoinNode::EventNode( group ),
         slots_( deps ... )
     {
         this->RegisterMe();
@@ -340,21 +340,21 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 
     ~EventJoinNode()
     {
-        std::apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
+        apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Move events into buffers.
-        std::apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
+        apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
 
         while (true)
         {
             bool isReady = true;
 
             // All slots ready?
-            std::apply(
+            apply(
                 [this, &isReady] (Slot<Ts>& ... slots)
                 {
                     // Todo: combine return values instead
@@ -366,7 +366,7 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
                 break;
 
             // Pop values from buffers and emit tuple.
-            std::apply(
+            apply(
                 [this] (Slot<Ts>& ... slots)
                 {
                     this->Events().emplace_back(slots.buffer.front() ...);
@@ -419,11 +419,11 @@ class EventJoinNode : public EventStreamNode<std::tuple<Ts ...>>
 /// EventLinkNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E>
-class EventLinkNode : public EventStreamNode<E>
+class EventLinkNode : public EventNode<E>
 {
 public:
     EventLinkNode(const Group& group, const Event<E>& dep) :
-        EventLinkNode::EventStreamNode( group ),
+        EventLinkNode::EventNode( group ),
         linkOutput_( dep )
     {
         this->RegisterMe(NodeCategory::input);
@@ -480,7 +480,7 @@ class EventLinkNode : public EventStreamNode<E>
                         NodeId nodeId = storedParent->GetNodeId();
                         auto& graphPtr = storedParent->GetGraphPtr();
 
-                        graphPtr->AddInput(nodeId,
+                        graphPtr->PushInput(nodeId,
                             [&storedParent, &storedEvents]
                             {
                                 storedParent->SetEvents(std::move(storedEvents));
@@ -512,14 +512,14 @@ class EventInternals
     EventInternals(EventInternals&&) = default;
     EventInternals& operator=(EventInternals&&) = default;
 
-    explicit EventInternals(std::shared_ptr<EventStreamNode<E>>&& nodePtr) :
+    explicit EventInternals(std::shared_ptr<EventNode<E>>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
     { }
 
-    auto GetNodePtr() -> std::shared_ptr<EventStreamNode<E>>&
+    auto GetNodePtr() -> std::shared_ptr<EventNode<E>>&
         { return nodePtr_; }
 
-    auto GetNodePtr() const -> const std::shared_ptr<EventStreamNode<E>>&
+    auto GetNodePtr() const -> const std::shared_ptr<EventNode<E>>&
         { return nodePtr_; }
 
     NodeId GetNodeId() const
@@ -532,7 +532,7 @@ class EventInternals
         { return nodePtr_->Events(); }
 
 private:
-    std::shared_ptr<EventStreamNode<E>> nodePtr_;
+    std::shared_ptr<EventNode<E>> nodePtr_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/graph_impl.h b/include/react/detail/graph_impl.h
index 133ffbe6..42c04789 100644
--- a/include/react/detail/graph_impl.h
+++ b/include/react/detail/graph_impl.h
@@ -18,7 +18,6 @@
 #include <vector>
 #include <map>
 #include <mutex>
-#include <optional>
 
 #include <tbb/concurrent_queue.h>
 #include <tbb/task.h>
@@ -39,16 +38,10 @@ class TransactionQueue
         graph_( graph )
     { }
 
-    TransactionQueue(const TransactionQueue&) = delete;
-    TransactionQueue& operator=(const TransactionQueue&) = delete;
-
-    TransactionQueue(TransactionQueue&&) = default;
-    TransactionQueue& operator =(TransactionQueue&&) = default;
-
     template <typename F>
     void Push(F&& func, SyncPoint::Dependency dep, TransactionFlags flags)
     {
-        transactions_.push(StoredTransaction{ std::forward<F>(transaction), std::move(dep), flags });
+        transactions_.push(StoredTransaction{ std::forward<F>(func), std::move(dep), flags });
 
         if (count_.fetch_add(1, std::memory_order_release) == 0)
             tbb::task::enqueue(*new(tbb::task::allocate_root()) WorkerTask(*this));
@@ -57,9 +50,9 @@ class TransactionQueue
 private:
     struct StoredTransaction
     {
-        std::function<void()>       func;
-        SyncPoint::DependencyList   deps;
-        TransactionFlags            flags;
+        std::function<void()>   func;
+        SyncPoint::Dependency   dep;
+        TransactionFlags        flags;
     };
 
     class WorkerTask : public tbb::task
@@ -67,7 +60,7 @@ class TransactionQueue
     public:
         WorkerTask(TransactionQueue& parent) :
             parent_( parent )
-            { }
+        { }
 
         tbb::task* execute()
         {
@@ -104,13 +97,15 @@ class ReactGraph
     template <typename F>
     void PushInput(NodeId nodeId, F&& inputCallback);
 
-    void PushDependency(SyncPoint::Dependency dep);
+    void AddSyncPointDependency(SyncPoint::Dependency dep, bool syncLinked);
+
+    void AllowLinkedTransactionMerging(bool allowMerging);
 
     template <typename F>
     void DoTransaction(F&& transactionCallback);
 
     template <typename F>
-    void EnqueueTransaction(F&& func, SyncPoint::DependencyList&& deps, TransactionFlags flags);
+    void EnqueueTransaction(F&& func, SyncPoint::Dependency dep, TransactionFlags flags);
     
     LinkCache& GetLinkCache()
         { return linkCache_; }
@@ -173,18 +168,20 @@ class ReactGraph
 
     SlotMap<NodeData>   nodeData_;
 
-    TopoQueue           scheduledNodes_;
+    TopoQueue scheduledNodes_;
 
     std::vector<NodeId>         changedInputs_;
     std::vector<IReactNode*>    changedNodes_;
 
-    std::vector<SyncPoint::Dependency> curDependencies_;
+    LinkOutputMap scheduledLinkOutputs_;
 
-    LinkOutputMap       scheduledLinkOutputs_;
+    std::vector<SyncPoint::Dependency> localDependencies_;
+    std::vector<SyncPoint::Dependency> linkDependencies_;
 
-    LinkCache           linkCache_;
+    LinkCache linkCache_;
 
     bool isTransactionActive_ = false;
+    bool allowLinkedTransactionMerging_ = false;
 };
 
 template <typename F>
@@ -214,9 +211,9 @@ void ReactGraph::DoTransaction(F&& transactionCallback)
 }
 
 template <typename F>
-void ReactGraph::EnqueueTransaction(F&& func, SyncPoint::DependencyList&& deps, TransactionFlags flags)
+void ReactGraph::EnqueueTransaction(F&& func, SyncPoint::Dependency dep, TransactionFlags flags)
 {
-    transactionQueue_.Push(std::forward<F>(func), std::move(deps), flags);
+    transactionQueue_.Push(std::forward<F>(func), std::move(dep), flags);
 }
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/observer_nodes.h b/include/react/detail/observer_nodes.h
index 35c160b1..9634c89c 100644
--- a/include/react/detail/observer_nodes.h
+++ b/include/react/detail/observer_nodes.h
@@ -11,9 +11,11 @@
 
 #include "react/detail/defs.h"
 #include "react/api.h"
+#include "react/common/utility.h"
 
 #include <memory>
 #include <utility>
+#include <tuple>
 
 #include "node_base.h"
 
@@ -23,13 +25,13 @@
 /// Forward declarations
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalNode;
+class StateNode;
 
 template <typename E>
 class EventStreamNode;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalObserverNode
+/// StateObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 class ObserverNode : public NodeBase
 {
@@ -40,39 +42,43 @@ class ObserverNode : public NodeBase
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalObserverNode
+/// StateObserverNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename F, typename ... TDeps>
-class SignalObserverNode : public ObserverNode
+class StateObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SignalObserverNode(const Group& group, FIn&& func, const Signal<TDeps>& ... deps) :
-        SignalObserverNode::ObserverNode( group ),
+    StateObserverNode(const Group& group, FIn&& func, const State<TDeps>& ... deps) :
+        StateObserverNode::ObserverNode( group ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
         this->RegisterMe(NodeCategory::output);
         REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
+
+        apply([this] (const auto& ... deps)
+            { this->func_(GetInternals(deps).Value() ...); }, depHolder_);
     }
 
-    ~SignalObserverNode()
+    ~StateObserverNode()
     {
-        std::apply([this] (const auto& ... deps)
+        apply([this] (const auto& ... deps)
             { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        std::apply([this] (const auto& ... deps) { this->func_(GetInternals(deps).Value() ...); }, depHolder_);
+        apply([this] (const auto& ... deps)
+            { this->func_(GetInternals(deps).Value() ...); }, depHolder_);
         return UpdateResult::unchanged;
     }
 
 private:
     F func_;
 
-    std::tuple<Signal<TDeps> ...> depHolder_;
+    std::tuple<State<TDeps> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -118,7 +124,7 @@ class SyncedEventObserverNode : public ObserverNode
 {
 public:
     template <typename FIn>
-    SyncedEventObserverNode(const Group& group, FIn&& func, const Event<E>& subject, const Signal<TSyncs>& ... syncs) :
+    SyncedEventObserverNode(const Group& group, FIn&& func, const Event<E>& subject, const State<TSyncs>& ... syncs) :
         SyncedEventObserverNode::ObserverNode( group ),
         func_( std::forward<FIn>(func) ),
         subject_( subject ),
@@ -131,7 +137,7 @@ class SyncedEventObserverNode : public ObserverNode
 
     ~SyncedEventObserverNode()
     {
-        std::apply([this] (const auto& ... syncs)
+        apply([this] (const auto& ... syncs)
             { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(subject_).GetNodeId());
         this->UnregisterMe();
@@ -143,7 +149,7 @@ class SyncedEventObserverNode : public ObserverNode
         if (GetInternals(this->subject_).Events().empty())
             return UpdateResult::unchanged;
 
-        std::apply([this] (const auto& ... syncs)
+        apply([this] (const auto& ... syncs)
             { func_(EventRange<E>( GetInternals(this->subject_).Events() ), GetInternals(syncs).Value() ...); }, syncHolder_);
 
         return UpdateResult::unchanged;
@@ -154,7 +160,39 @@ class SyncedEventObserverNode : public ObserverNode
 
     Event<E> subject_;
 
-    std::tuple<Signal<TSyncs> ...> syncHolder_;
+    std::tuple<State<TSyncs> ...> syncHolder_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// ObserverInternals
+///////////////////////////////////////////////////////////////////////////////////////////////////
+class ObserverInternals
+{
+public:
+    ObserverInternals(const ObserverInternals&) = default;
+    ObserverInternals& operator=(const ObserverInternals&) = default;
+
+    ObserverInternals(ObserverInternals&&) = default;
+    ObserverInternals& operator=(ObserverInternals&&) = default;
+
+    explicit ObserverInternals(std::shared_ptr<ObserverNode>&& nodePtr) :
+        nodePtr_( std::move(nodePtr) )
+    { }
+
+    auto GetNodePtr() -> std::shared_ptr<ObserverNode>&
+        { return nodePtr_; }
+
+    auto GetNodePtr() const -> const std::shared_ptr<ObserverNode>&
+        { return nodePtr_; }
+
+    NodeId GetNodeId() const
+        { return nodePtr_->GetNodeId(); }
+
+protected:
+    ObserverInternals() = default;
+
+private:
+    std::shared_ptr<ObserverNode> nodePtr_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/signal_nodes.h b/include/react/detail/state_nodes.h
similarity index 75%
rename from include/react/detail/signal_nodes.h
rename to include/react/detail/state_nodes.h
index f97dc908..655ab542 100644
--- a/include/react/detail/signal_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#ifndef REACT_DETAIL_GRAPH_SIGNALNODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_SIGNALNODES_H_INCLUDED
+#ifndef REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
+#define REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
 
 #include "react/detail/defs.h"
 
@@ -27,26 +27,26 @@ template <typename L, typename R>
 bool Equals(const L& lhs, const R& rhs);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalNode
+/// StateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalNode : public NodeBase
+class StateNode : public NodeBase
 {
 public:
-    SignalNode(SignalNode&&) = default;
-    SignalNode& operator=(SignalNode&&) = default;
+    StateNode(StateNode&&) = default;
+    StateNode& operator=(StateNode&&) = default;
 
-    SignalNode(const SignalNode&) = delete;
-    SignalNode& operator=(const SignalNode&) = delete;
+    StateNode(const StateNode&) = delete;
+    StateNode& operator=(const StateNode&) = delete;
 
-    explicit SignalNode(const Group& group) :
-        SignalNode::NodeBase( group ),
+    explicit StateNode(const Group& group) :
+        StateNode::NodeBase( group ),
         value_( )
     { }
 
     template <typename T>
-    SignalNode(const Group& group, T&& value) :
-        SignalNode::NodeBase( group ),
+    StateNode(const Group& group, T&& value) :
+        StateNode::NodeBase( group ),
         value_( std::forward<T>(value) )
     { }
 
@@ -64,25 +64,25 @@ class SignalNode : public NodeBase
 /// VarNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class VarSignalNode : public SignalNode<S>
+class StateVarNode : public StateNode<S>
 {
 public:
-    explicit VarSignalNode(const Group& group) :
-        VarSignalNode::SignalNode( group ),
+    explicit StateVarNode(const Group& group) :
+        StateVarNode::StateNode( group ),
         newValue_( )
     {
         this->RegisterMe(NodeCategory::input);
     }
 
     template <typename T>
-    VarSignalNode(const Group& group, T&& value) :
-        VarSignalNode::SignalNode( group, std::forward<T>(value) ),
+    StateVarNode(const Group& group, T&& value) :
+        StateVarNode::StateNode( group, std::forward<T>(value) ),
         newValue_( value )
     {
         this->RegisterMe();
     }
 
-    ~VarSignalNode()
+    ~StateVarNode()
     {
         this->UnregisterMe();
     }
@@ -127,7 +127,6 @@ class VarSignalNode : public SignalNode<S>
         isInputModified_ = false;
     }
 
-    // This is signal-specific
     template <typename F>
     void ModifyValue(F&& func)
     {
@@ -154,15 +153,15 @@ class VarSignalNode : public SignalNode<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalOpNode
+/// StateOpNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename F, typename ... TDeps>
-class SignalFuncNode : public SignalNode<S>
+class StateFuncNode : public StateNode<S>
 {
 public:
     template <typename FIn>
-    SignalFuncNode(const Group& group, FIn&& func, const Signal<TDeps>& ... deps) :
-        SignalFuncNode::SignalNode( group, func(GetInternals(deps).Value() ...) ),
+    StateFuncNode(const Group& group, FIn&& func, const State<TDeps>& ... deps) :
+        StateFuncNode::StateNode( group, func(GetInternals(deps).Value() ...) ),
         func_( std::forward<FIn>(func) ),
         depHolder_( deps ... )
     {
@@ -170,9 +169,9 @@ class SignalFuncNode : public SignalNode<S>
         REACT_EXPAND_PACK(this->AttachToMe(GetInternals(deps).GetNodeId()));
     }
 
-    ~SignalFuncNode()
+    ~StateFuncNode()
     {
-        std::apply([this] (const auto& ... deps)
+        apply([this] (const auto& ... deps)
             { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodePtr()->GetNodeId())); }, depHolder_);
         this->UnregisterMe();
     }
@@ -181,7 +180,7 @@ class SignalFuncNode : public SignalNode<S>
     {   
         bool changed = false;
 
-        S newValue = std::apply([this] (const auto& ... deps)
+        S newValue = apply([this] (const auto& ... deps)
             { return this->func_(GetInternals(deps).Value() ...); }, depHolder_);
 
         if (! (this->Value() == newValue))
@@ -198,18 +197,18 @@ class SignalFuncNode : public SignalNode<S>
 
 private:
     F func_;
-    std::tuple<Signal<TDeps> ...> depHolder_;
+    std::tuple<State<TDeps> ...> depHolder_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalSlotNode
+/// StateSlotNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalSlotNode : public SignalNode<S>
+class StateSlotNode : public StateNode<S>
 {
 public:
-    SignalSlotNode(const Group& group, const Signal<S>& dep) :
-        SignalSlotNode::SignalNode( group, GetInternals(dep).Value() ),
+    StateSlotNode(const Group& group, const State<S>& dep) :
+        StateSlotNode::StateNode( group, GetInternals(dep).Value() ),
         input_( dep )
     {
         inputNodeId_ = GetGraphPtr()->RegisterNode(&slotInput_, NodeCategory::dyninput);
@@ -219,7 +218,7 @@ class SignalSlotNode : public SignalNode<S>
         this->AttachToMe(GetInternals(dep).GetNodeId());
     }
 
-    ~SignalSlotNode()
+    ~StateSlotNode()
     {
         this->DetachFromMe(GetInternals(input_).GetNodeId());
         this->DetachFromMe(inputNodeId_);
@@ -241,7 +240,7 @@ class SignalSlotNode : public SignalNode<S>
         }
     }
 
-    void SetInput(const Signal<S>& newInput)
+    void SetInput(const State<S>& newInput)
     {
         if (newInput == input_)
             return;
@@ -262,36 +261,35 @@ class SignalSlotNode : public SignalNode<S>
             { return UpdateResult::changed; }
     };
 
-    Signal<S>           input_;
+    State<S>           input_;
     NodeId              inputNodeId_;
     VirtualInputNode    slotInput_;
     
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalLinkNode
+/// StateLinkNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalLinkNode : public SignalNode<S>
+class StateLinkNode : public StateNode<S>
 {
 public:
-    SignalLinkNode(const Group& group, const Signal<S>& dep) :
-        SignalLinkNode::SignalNode( group, GetInternals(dep).Value() ),
-        dep_ ( dep )
+    StateLinkNode(const Group& group, const State<S>& dep) :
+        StateLinkNode::StateNode( group, GetInternals(dep).Value() ),
+        dep_ ( dep ),
+        srcGroup_( dep.GetGroup() )
     {
         this->RegisterMe(NodeCategory::input);
 
-        auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
-        outputNodeId_ = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
+        auto& srcGraphPtr = GetInternals(srcGroup_).GetGraphPtr();
+        outputNodeId_ = srcGraphPtr->RegisterNode(&linkOutput_, NodeCategory::linkoutput);
         
         srcGraphPtr->AttachNode(outputNodeId_, GetInternals(dep).GetNodeId());
     }
 
-    ~SignalLinkNode()
+    ~StateLinkNode()
     {
-        this->DetachFromMe(GetInternals(dep_).GetNodeId());
-
-        auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
+        auto& srcGraphPtr = GetInternals(srcGroup_).GetGraphPtr();
         srcGraphPtr->DetachNode(outputNodeId_, GetInternals(dep_).GetNodeId());
         srcGraphPtr->UnregisterNode(outputNodeId_);
 
@@ -301,7 +299,7 @@ class SignalLinkNode : public SignalNode<S>
         this->UnregisterMe();
     }
 
-    void SetWeakSelfPtr(const std::weak_ptr<SignalLinkNode>& self)
+    void SetWeakSelfPtr(const std::weak_ptr<StateLinkNode>& self)
         { linkOutput_.parent = self; }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
@@ -327,7 +325,7 @@ class SignalLinkNode : public SignalNode<S>
                         NodeId nodeId = storedParent->GetNodeId();
                         auto& graphPtr = storedParent->GetGraphPtr();
 
-                        graphPtr->AddInput(nodeId,
+                        graphPtr->PushInput(nodeId,
                             [&storedParent, &storedValue]
                             {
                                 storedParent->SetValue(std::move(storedValue));
@@ -336,37 +334,38 @@ class SignalLinkNode : public SignalNode<S>
             }
         }
 
-        std::weak_ptr<SignalLinkNode> parent;
+        std::weak_ptr<StateLinkNode> parent;
     };
 
-    Signal<S>   dep_;
-    Group       srcGroup;
+    State<S>    dep_;
+    Group       srcGroup_;
     NodeId      outputNodeId_;
+
     VirtualOutputNode linkOutput_;
 };
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalInternals
+/// StateInternals
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalInternals
+class StateInternals
 {
 public:
-    SignalInternals(const SignalInternals&) = default;
-    SignalInternals& operator=(const SignalInternals&) = default;
+    StateInternals(const StateInternals&) = default;
+    StateInternals& operator=(const StateInternals&) = default;
 
-    SignalInternals(SignalInternals&&) = default;
-    SignalInternals& operator=(SignalInternals&&) = default;
+    StateInternals(StateInternals&&) = default;
+    StateInternals& operator=(StateInternals&&) = default;
 
-    explicit SignalInternals(std::shared_ptr<SignalNode<S>>&& nodePtr) :
+    explicit StateInternals(std::shared_ptr<StateNode<S>>&& nodePtr) :
         nodePtr_( std::move(nodePtr) )
     { }
 
-    auto GetNodePtr() -> std::shared_ptr<SignalNode<S>>&
+    auto GetNodePtr() -> std::shared_ptr<StateNode<S>>&
         { return nodePtr_; }
 
-    auto GetNodePtr() const -> const std::shared_ptr<SignalNode<S>>&
+    auto GetNodePtr() const -> const std::shared_ptr<StateNode<S>>&
         { return nodePtr_; }
 
     NodeId GetNodeId() const
@@ -379,9 +378,9 @@ class SignalInternals
         { return nodePtr_->Value(); }
 
 private:
-    std::shared_ptr<SignalNode<S>> nodePtr_;
+    std::shared_ptr<StateNode<S>> nodePtr_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_GRAPH_SIGNALNODES_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/Signal.h b/include/react/state.h
similarity index 51%
rename from include/react/Signal.h
rename to include/react/state.h
index c7e11e8f..95d80b6c 100644
--- a/include/react/Signal.h
+++ b/include/react/state.h
@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_SIGNAL_H_INCLUDED
-#define REACT_SIGNAL_H_INCLUDED
+#ifndef REACT_STATE_H_INCLUDED
+#define REACT_STATE_H_INCLUDED
 
 #pragma once
 
@@ -19,34 +19,34 @@
 #include <type_traits>
 #include <utility>
 
-#include "react/detail/signal_nodes.h"
+#include "react/detail/state_nodes.h"
 
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signal
+/// State
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class Signal : protected REACT_IMPL::SignalInternals<S>
+class State : protected REACT_IMPL::StateInternals<S>
 {
 public:
-    Signal(const Signal&) = default;
-    Signal& operator=(const Signal&) = default;
+    State(const State&) = default;
+    State& operator=(const State&) = default;
 
-    Signal(Signal&&) = default;
-    Signal& operator=(Signal&&) = default;
+    State(State&&) = default;
+    State& operator=(State&&) = default;
 
     // Construct with explicit group
     template <typename F, typename T1, typename ... Ts>
-    explicit Signal(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
-        Signal::SignalInternals( CreateFuncNode(group, std::forward<F>(func), dep1, deps ...) )
+    explicit State(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) :
+        State::StateInternals( CreateFuncNode(group, std::forward<F>(func), dep1, deps ...) )
     { }
 
     // Construct with implicit group
     template <typename F, typename T1, typename ... Ts>
-    explicit Signal(F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) :
-        Signal::SignalInternals( CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...) )
+    explicit State(F&& func, const State<T1>& dep1, const State<Ts>& ... deps) :
+        State::StateInternals( CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...) )
     { }
 
     auto GetGroup() const -> const Group&
@@ -55,31 +55,31 @@ class Signal : protected REACT_IMPL::SignalInternals<S>
     auto GetGroup() -> Group&
         { return this->GetNodePtr()->GetGroup(); }
 
-    friend bool operator==(const Signal<S>& a, const Signal<S>& b)
+    friend bool operator==(const State<S>& a, const State<S>& b)
         { return a.GetNodePtr() == b.GetNodePtr(); }
 
-    friend bool operator!=(const Signal<S>& a, const Signal<S>& b)
+    friend bool operator!=(const State<S>& a, const State<S>& b)
         { return !(a == b); }
 
-    friend auto GetInternals(Signal<S>& s) -> REACT_IMPL::SignalInternals<S>&
+    friend auto GetInternals(State<S>& s) -> REACT_IMPL::StateInternals<S>&
         { return s; }
 
-    friend auto GetInternals(const Signal<S>& s) -> const REACT_IMPL::SignalInternals<S>&
+    friend auto GetInternals(const State<S>& s) -> const REACT_IMPL::StateInternals<S>&
         { return s; }
 
 protected:
-    explicit Signal(std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
-        Signal::SignalInternals( std::move(nodePtr) )
+    explicit State(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+        State::StateInternals( std::move(nodePtr) )
     { }
 
 private:
     template <typename F, typename T1, typename ... Ts>
-    auto CreateFuncNode(const Group& group, F&& func, const Signal<T1>& dep1, const Signal<Ts>& ... deps) -> decltype(auto)
+    auto CreateFuncNode(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) -> decltype(auto)
     {
-        using REACT_IMPL::SignalFuncNode;
+        using REACT_IMPL::StateFuncNode;
         using REACT_IMPL::SameGroupOrLink;
 
-        return std::make_shared<SignalFuncNode<S, typename std::decay<F>::type, T1, Ts ...>>(
+        return std::make_shared<StateFuncNode<S, typename std::decay<F>::type, T1, Ts ...>>(
             group, std::forward<F>(func), SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
     }
 
@@ -88,27 +88,27 @@ class Signal : protected REACT_IMPL::SignalInternals<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// VarSignal
+/// StateVar
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class VarSignal : public Signal<S>
+class StateVar : public State<S>
 {
 public:
-    VarSignal(const VarSignal&) = default;
-    VarSignal& operator=(const VarSignal&) = default;
+    StateVar(const StateVar&) = default;
+    StateVar& operator=(const StateVar&) = default;
 
-    VarSignal(VarSignal&&) = default;
-    VarSignal& operator=(VarSignal&&) = default;
+    StateVar(StateVar&&) = default;
+    StateVar& operator=(StateVar&&) = default;
 
     // Construct with group + default
-    explicit VarSignal(const Group& group) :
-        VarSignal::Signal( CreateVarNode(group) )
+    explicit StateVar(const Group& group) :
+        StateVar::State( CreateVarNode(group) )
     { }
 
     // Construct with group + value
     template <typename T>
-    VarSignal(const Group& group, T&& value) :
-        VarSignal::Signal( CreateVarNode(group, std::forward<T>(value)) )
+    StateVar(const Group& group, T&& value) :
+        StateVar::State( CreateVarNode(group, std::forward<T>(value)) )
     { }
 
     void Set(const S& newValue)
@@ -121,140 +121,140 @@ class VarSignal : public Signal<S>
     void Modify(const F& func)
         { ModifyValue(func); }
 
-    friend bool operator==(const VarSignal<S>& a, VarSignal<S>& b)
+    friend bool operator==(const StateVar<S>& a, StateVar<S>& b)
         { return a.GetNodePtr() == b.GetNodePtr(); }
 
-    friend bool operator!=(const VarSignal<S>& a, VarSignal<S>& b)
+    friend bool operator!=(const StateVar<S>& a, StateVar<S>& b)
         { return !(a == b); }
 
 protected:
-    explicit VarSignal(std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
-        VarSignal::Signal( std::move(nodePtr) )
+    explicit StateVar(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+        StateVar::State( std::move(nodePtr) )
     { }
 
 private:
     static auto CreateVarNode(const Group& group) -> decltype(auto)
     {
-        using REACT_IMPL::VarSignalNode;
-        return std::make_shared<VarSignalNode<S>>(group);
+        using REACT_IMPL::StateVarNode;
+        return std::make_shared<StateVarNode<S>>(group);
     }
 
     template <typename T>
     static auto CreateVarNode(const Group& group, T&& value) -> decltype(auto)
     {
-        using REACT_IMPL::VarSignalNode;
-        return std::make_shared<VarSignalNode<S>>(group, std::forward<T>(value));
+        using REACT_IMPL::StateVarNode;
+        return std::make_shared<StateVarNode<S>>(group, std::forward<T>(value));
     }
 
     template <typename T>
     void SetValue(T&& newValue)
     {
         using REACT_IMPL::NodeId;
-        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
+        using VarNodeType = REACT_IMPL::StateVarNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr, &newValue] { castedPtr->SetValue(std::forward<T>(newValue)); });
+        graphPtr->PushInput(nodeId, [castedPtr, &newValue] { castedPtr->SetValue(std::forward<T>(newValue)); });
     }
 
     template <typename F>
     void ModifyValue(const F& func)
     {
         using REACT_IMPL::NodeId;
-        using VarNodeType = REACT_IMPL::VarSignalNode<S>;
+        using VarNodeType = REACT_IMPL::StateVarNode<S>;
 
         VarNodeType* castedPtr = static_cast<VarNodeType*>(this->GetNodePtr().get());
         
         NodeId nodeId = castedPtr->GetNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [castedPtr, &func] { castedPtr->ModifyValue(func); });
+        graphPtr->PushInput(nodeId, [castedPtr, &func] { castedPtr->ModifyValue(func); });
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalSlotBase
+/// StateSlotBase
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalSlot : public Signal<S>
+class StateSlot : public State<S>
 {
 public:
-    SignalSlot(const SignalSlot&) = default;
-    SignalSlot& operator=(const SignalSlot&) = default;
+    StateSlot(const StateSlot&) = default;
+    StateSlot& operator=(const StateSlot&) = default;
 
-    SignalSlot(SignalSlot&&) = default;
-    SignalSlot& operator=(SignalSlot&&) = default;
+    StateSlot(StateSlot&&) = default;
+    StateSlot& operator=(StateSlot&&) = default;
 
     // Construct with explicit group
-    SignalSlot(const Group& group, const Signal<S>& input) :
-        SignalSlot::Signal( CreateSlotNode(group, input) )
+    StateSlot(const Group& group, const State<S>& input) :
+        StateSlot::State( CreateSlotNode(group, input) )
     { }
 
     // Construct with implicit group
-    explicit SignalSlot(const Signal<S>& input) :
-        SignalSlot::Signal( CreateSlotNode(input.GetGroup(), input) )
+    explicit StateSlot(const State<S>& input) :
+        StateSlot::State( CreateSlotNode(input.GetGroup(), input) )
     { }
 
-    void Set(const Signal<S>& newInput)
+    void Set(const State<S>& newInput)
         { SetInput(newInput); }
 
-    void operator<<=(const Signal<S>& newInput)
+    void operator<<=(const State<S>& newInput)
         { SetInput(newInput); }
 
 protected:
-    explicit SignalSlot(std::shared_ptr<REACT_IMPL::SignalNode<S>>&& nodePtr) :
-        SignalSlot::Signal( std::move(nodePtr) )
+    explicit StateSlot(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+        StateSlot::State( std::move(nodePtr) )
     { }
 
 private:
-    static auto CreateSlotNode(const Group& group, const Signal<S>& input) -> decltype(auto)
+    static auto CreateSlotNode(const Group& group, const State<S>& input) -> decltype(auto)
     {
-        using REACT_IMPL::SignalSlotNode;
+        using REACT_IMPL::StateSlotNode;
         using REACT_IMPL::SameGroupOrLink;
 
-        return std::make_shared<SignalSlotNode<S>>(group, SameGroupOrLink(group, input));
+        return std::make_shared<StateSlotNode<S>>(group, SameGroupOrLink(group, input));
     }
 
-    void SetInput(const Signal<S>& newInput)
+    void SetInput(const State<S>& newInput)
     {
         using REACT_IMPL::NodeId;
-        using REACT_IMPL::SignalSlotNode;
+        using REACT_IMPL::StateSlotNode;
         using REACT_IMPL::SameGroupOrLink;
 
-        auto* castedPtr = static_cast<SignalSlotNode<S>*>(this->GetNodePtr().get());
+        auto* castedPtr = static_cast<StateSlotNode<S>*>(this->GetNodePtr().get());
 
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->AddInput(nodeId, [this, castedPtr, &newInput] { castedPtr->SetInput(SameGroupOrLink(GetGroup(), newInput)); });
+        graphPtr->PushInput(nodeId, [this, castedPtr, &newInput] { castedPtr->SetInput(SameGroupOrLink(GetGroup(), newInput)); });
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalLink
+/// StateLink
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class SignalLink : public Signal<S>
+class StateLink : public State<S>
 {
 public:
-    SignalLink(const SignalLink&) = default;
-    SignalLink& operator=(const SignalLink&) = default;
+    StateLink(const StateLink&) = default;
+    StateLink& operator=(const StateLink&) = default;
 
-    SignalLink(SignalLink&&) = default;
-    SignalLink& operator=(SignalLink&&) = default;
+    StateLink(StateLink&&) = default;
+    StateLink& operator=(StateLink&&) = default;
 
     // Construct with group
-    SignalLink(const Group& group, const Signal<S>& input) :
-        SignalLink::Signal( GetOrCreateLinkNode(group, input) )
+    StateLink(const Group& group, const State<S>& input) :
+        StateLink::State( GetOrCreateLinkNode(group, input) )
     { }
 
 protected:
-    static auto GetOrCreateLinkNode(const Group& group, const Signal<S>& input) -> decltype(auto)
+    static auto GetOrCreateLinkNode(const Group& group, const State<S>& input) -> decltype(auto)
     {
-        using REACT_IMPL::SignalLinkNode;
+        using REACT_IMPL::StateLinkNode;
         using REACT_IMPL::IReactNode;
         using REACT_IMPL::ReactGraph;
         
@@ -266,12 +266,12 @@ class SignalLink : public Signal<S>
             k,
             [&]
             {
-                auto nodePtr = std::make_shared<SignalLinkNode<S>>(group, input);
-                nodePtr->SetWeakSelfPtr(std::weak_ptr<SignalLinkNode<S>>{ nodePtr });
+                auto nodePtr = std::make_shared<StateLinkNode<S>>(group, input);
+                nodePtr->SetWeakSelfPtr(std::weak_ptr<StateLinkNode<S>>{ nodePtr });
                 return std::static_pointer_cast<IReactNode>(nodePtr);
             });
 
-        return std::static_pointer_cast<SignalLinkNode<S>>(nodePtr);
+        return std::static_pointer_cast<StateLinkNode<S>>(nodePtr);
     }
 };
 
@@ -280,14 +280,14 @@ class SignalLink : public Signal<S>
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
 template <typename S>
-static Signal<S> SameGroupOrLink(const Group& targetGroup, const Signal<S>& dep)
+static State<S> SameGroupOrLink(const Group& targetGroup, const State<S>& dep)
 {
     if (dep.GetGroup() == targetGroup)
         return dep;
     else
-        return SignalLink<S>( targetGroup, dep );
+        return StateLink<S>( targetGroup, dep );
 }
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_SIGNAL_H_INCLUDED
\ No newline at end of file
+#endif // REACT_STATE_H_INCLUDED
\ No newline at end of file
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 68b88817..1867d880 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -106,7 +106,6 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Cpp0xSupport>true</Cpp0xSupport>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -145,7 +144,6 @@
       <AdditionalIncludeDirectories>$(SolutionDir)..\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Cpp0xSupport>true</Cpp0xSupport>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -170,11 +168,11 @@
     <ClInclude Include="..\..\include\react\detail\node_base.h" />
     <ClInclude Include="..\..\include\react\detail\observer_nodes.h" />
     <ClInclude Include="..\..\include\react\detail\graph_impl.h" />
-    <ClInclude Include="..\..\include\react\detail\signal_nodes.h" />
+    <ClInclude Include="..\..\include\react\detail\state_nodes.h" />
     <ClInclude Include="..\..\include\react\event.h" />
     <ClInclude Include="..\..\include\react\group.h" />
     <ClInclude Include="..\..\include\react\observer.h" />
-    <ClInclude Include="..\..\include\react\signal.h" />
+    <ClInclude Include="..\..\include\react\state.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\src\detail\graph_impl.cpp" />
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index d87af090..040e8acc 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -39,9 +39,6 @@
     <ClInclude Include="..\..\include\react\observer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\signal.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\detail\algorithm_nodes.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
@@ -60,9 +57,6 @@
     <ClInclude Include="..\..\include\react\detail\observer_nodes.h">
       <Filter>Header Files\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\include\react\detail\signal_nodes.h">
-      <Filter>Header Files\detail</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\include\react\algorithm.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -81,6 +75,12 @@
     <ClInclude Include="..\..\include\react\common\utility.h">
       <Filter>Header Files\common</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\include\react\detail\state_nodes.h">
+      <Filter>Header Files\detail</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\react\state.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp">
diff --git a/project/msvc/CppReactTest.vcxproj b/project/msvc/CppReactTest.vcxproj
index eccef6a3..7516767f 100644
--- a/project/msvc/CppReactTest.vcxproj
+++ b/project/msvc/CppReactTest.vcxproj
@@ -168,8 +168,8 @@
     <ClCompile Include="..\..\tests\src\ObserverTest.cpp" />
     <ClCompile Include="..\..\tests\src\OperationsTest.cpp" />
     <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp" />
-    <ClCompile Include="..\..\tests\src\SignalTest.cpp" />
-    <ClCompile Include="..\..\tests\src\TransactionTest.cpp" />
+    <ClCompile Include="..\..\tests\src\state_tests.cpp" />
+    <ClCompile Include="..\..\tests\src\transaction_tests.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
diff --git a/project/msvc/CppReactTest.vcxproj.filters b/project/msvc/CppReactTest.vcxproj.filters
index a6f9919a..6004eeed 100644
--- a/project/msvc/CppReactTest.vcxproj.filters
+++ b/project/msvc/CppReactTest.vcxproj.filters
@@ -24,19 +24,19 @@
     <ClCompile Include="..\..\tests\src\OperationsTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\SignalTest.cpp">
+    <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\TransactionTest.cpp">
+    <ClCompile Include="..\..\tests\src\event_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp">
+    <ClCompile Include="..\..\tests\src\common_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\event_tests.cpp">
+    <ClCompile Include="..\..\tests\src\transaction_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\tests\src\common_tests.cpp">
+    <ClCompile Include="..\..\tests\src\state_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
diff --git a/src/detail/graph_impl.cpp b/src/detail/graph_impl.cpp
index 8dc4be9a..c6ceb6be 100644
--- a/src/detail/graph_impl.cpp
+++ b/src/detail/graph_impl.cpp
@@ -54,9 +54,17 @@ void ReactGraph::DetachNode(NodeId nodeId, NodeId parentId)
     successors.erase(std::find(successors.begin(), successors.end(), nodeId));
 }
 
-void ReactGraph::PushDependency(SyncPoint::Dependency dep)
+void ReactGraph::AddSyncPointDependency(SyncPoint::Dependency dep, bool syncLinked)
 {
-    curDependencies_.push_back(std::move(dep));
+    if (syncLinked)
+        linkDependencies_.push_back(std::move(dep));
+    else
+        localDependencies_.push_back(std::move(dep));
+}
+
+void ReactGraph::AllowLinkedTransactionMerging(bool allowMerging)
+{
+    allowLinkedTransactionMerging_ = true;
 }
 
 void ReactGraph::Propagate()
@@ -115,21 +123,35 @@ void ReactGraph::Propagate()
     for (IReactNode* nodePtr : changedNodes_)
         nodePtr->Clear();
     changedNodes_.clear();
+
+    // Clean link state.
+    scheduledLinkOutputs_.clear();
+    localDependencies_.clear();
+    linkDependencies_.clear();
+    allowLinkedTransactionMerging_ = false;
 }
 
 void ReactGraph::UpdateLinkNodes()
 {
+    TransactionFlags flags = TransactionFlags::none;
+
+    if (! linkDependencies_.empty())
+        flags |= TransactionFlags::sync_linked;
+
+    if (allowLinkedTransactionMerging_)
+        flags |= TransactionFlags::allow_merging;
+
+    SyncPoint::Dependency dep{ begin(linkDependencies_), end(linkDependencies_) };
+
     for (auto& e : scheduledLinkOutputs_)
     {
-        e.first->EnqueueTransaction(TransactionFlags::none,
+        e.first->EnqueueTransaction(
             [inputs = std::move(e.second)]
             {
                 for (auto& callback : inputs)
                     callback();
-            });
+            }, dep, flags);
     }
-
-    scheduledLinkOutputs_.clear();
 }
 
 void ReactGraph::ScheduleSuccessors(NodeData& node)
@@ -197,7 +219,10 @@ size_t TransactionQueue::ProcessNextBatch()
 {
     StoredTransaction curTransaction;
     size_t popCount = 0;
+
     bool canMerge = false;
+    bool syncLinked = false;
+
     bool skipPop = false;
     bool isDone = false;
 
@@ -210,6 +235,8 @@ size_t TransactionQueue::ProcessNextBatch()
                 return popCount;
 
             canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
+            syncLinked = IsBitmaskSet(curTransaction.flags, TransactionFlags::sync_linked);
+
             ++popCount;
         }
         else
@@ -220,16 +247,21 @@ size_t TransactionQueue::ProcessNextBatch()
         graph_.DoTransaction([&]
         {
             curTransaction.func();
+            graph_.AddSyncPointDependency(std::move(curTransaction.dep), syncLinked);
 
             if (canMerge)
             {
-                // Inner loop. Mergeable transactions are merged
+                graph_.AllowLinkedTransactionMerging(true);
+
+                // Pull in additional mergeable transactions.
                 for (;;)
                 {
-                    if (transactions_.try_pop(curTransaction))
+                    if (!transactions_.try_pop(curTransaction))
                         return;
 
                     canMerge = IsBitmaskSet(curTransaction.flags, TransactionFlags::allow_merging);
+                    syncLinked = IsBitmaskSet(curTransaction.flags, TransactionFlags::sync_linked);
+
                     ++popCount;
 
                     if (!canMerge)
@@ -239,6 +271,7 @@ size_t TransactionQueue::ProcessNextBatch()
                     }
 
                     curTransaction.func();
+                    graph_.AddSyncPointDependency(std::move(curTransaction.dep), syncLinked);
                 }
             }
         });
diff --git a/tests/src/SignalTest.cpp b/tests/src/SignalTest.cpp
deleted file mode 100644
index a34b7f98..00000000
--- a/tests/src/SignalTest.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/TransactionTest.cpp b/tests/src/TransactionTest.cpp
deleted file mode 100644
index 6054092a..00000000
--- a/tests/src/TransactionTest.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/common_tests.cpp b/tests/src/common_tests.cpp
index 0bd5b6dc..8a78457a 100644
--- a/tests/src/common_tests.cpp
+++ b/tests/src/common_tests.cpp
@@ -15,6 +15,36 @@
 using namespace react;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+TEST(SyncPointTest, DependencyCreation)
+{
+    SyncPoint sp;
+
+    {
+        SyncPoint::Dependency dep1(sp);
+        SyncPoint::Dependency dep2(sp);
+        SyncPoint::Dependency dep3(sp);
+
+        std::vector<SyncPoint::Dependency> deps1 = { dep1, dep2, dep3 };
+        std::vector<SyncPoint::Dependency> deps2 = { dep1 };
+
+        SyncPoint::Dependency dep4( begin(deps1), end(deps1) );
+        
+
+        SyncPoint::Dependency dep5;
+
+        dep5 = std::move(dep4);
+
+        SyncPoint::Dependency dep6;
+        dep6 = dep5;
+        SyncPoint::Dependency dep7( dep6 );
+
+        SyncPoint::Dependency dep8( begin(deps2), end(deps2) );
+    }
+
+    bool done = sp.WaitFor(std::chrono::milliseconds(1));
+    EXPECT_EQ(true, done);
+}
+
 TEST(SyncPointTest, SingleWait)
 {
     SyncPoint sp;
@@ -29,7 +59,6 @@ TEST(SyncPointTest, SingleWait)
             output = 1;
         });
 
-    
     sp.Wait();
     
     EXPECT_EQ(1, output);
diff --git a/tests/src/event_tests.cpp b/tests/src/event_tests.cpp
index 4204a466..31565b87 100644
--- a/tests/src/event_tests.cpp
+++ b/tests/src/event_tests.cpp
@@ -80,7 +80,7 @@ TEST(EventTest, BasicOutput)
     EXPECT_EQ(3, output);
 }
 
-TEST(EventTest, EventSlots)
+TEST(EventTest, Slots)
 {
     Group g;
 
@@ -144,7 +144,7 @@ TEST(EventTest, EventSlots)
     EXPECT_EQ(4, turns);
 }
 
-TEST(EventTest, EventTransactions)
+TEST(EventTest, Transactions)
 {
     Group g;
 
@@ -174,7 +174,7 @@ TEST(EventTest, EventTransactions)
     EXPECT_EQ(1, turns);
 }
 
-TEST(EventTest, ExplicitEventLinks)
+TEST(EventTest, Links)
 {
     Group g1;
     Group g2;
diff --git a/tests/src/state_tests.cpp b/tests/src/state_tests.cpp
new file mode 100644
index 00000000..7cca28db
--- /dev/null
+++ b/tests/src/state_tests.cpp
@@ -0,0 +1,262 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include "gtest/gtest.h"
+
+#include "react/state.h"
+#include "react/observer.h"
+
+#include <thread>
+#include <chrono>
+
+using namespace react;
+
+TEST(StateTest, Construction)
+{
+    Group g;
+
+    // State variable
+    {
+        StateVar<int> t1( g, 0 );
+        StateVar<int> t2( t1 );
+        StateVar<int> t3( std::move(t1) );
+        
+        StateVar<int>   ref1( t2 );
+        State<int>      ref2( t3 );
+
+        EXPECT_TRUE(ref1 == ref2);
+    }
+
+    // State slot
+    {
+        StateVar<int> t0( g, 0 );
+
+        StateSlot<int> t1( g, t0 );
+        StateSlot<int> t2( t1 );
+        StateSlot<int> t3( std::move(t1) );
+        
+        StateSlot<int> ref1( t2 );
+        State<int>     ref2( t3 );
+
+        EXPECT_TRUE(ref1 == ref2);
+    }
+
+    // State link
+    {
+        StateVar<int> t0( g, 0 );
+
+        StateSlot<int> s1( g, t0 );
+
+        StateLink<int> t1( g, s1 );
+        StateLink<int> t2( t1 );
+        StateLink<int> t3( std::move(t1) );
+        
+        StateLink<int> ref1( t2 );
+        State<int>     ref2( t3 );
+
+        EXPECT_TRUE(ref1 == ref2);
+    }
+}
+
+TEST(StateTest, BasicOutput)
+{
+    Group g;
+
+    StateVar<int> st( g );
+
+    int output = 0;
+
+    Observer obs([&] (const auto& v)
+        {
+            output += v;
+        }, st);
+
+    EXPECT_EQ(0, output);
+
+    st.Set(1);
+    EXPECT_EQ(1, output);
+
+    st.Set(2);
+    EXPECT_EQ(3, output);
+}
+
+TEST(StateTest, Slots)
+{
+    Group g;
+
+    StateVar<int> st1( g );
+    StateVar<int> st2( g );
+
+    StateSlot<int> slot( g, st1 );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& v)
+        {
+            ++turns;
+            output += v;
+        }, slot);
+
+    EXPECT_EQ(0, output);
+    EXPECT_EQ(1, turns);
+
+    slot.Set(st1);
+    st1.Set(5);
+    st2.Set(2);
+
+    EXPECT_EQ(5, output);
+    EXPECT_EQ(2, turns);
+
+    output = 0;
+
+    slot.Set(st2);
+    st1.Set(5);
+    st2.Set(2);
+
+    EXPECT_EQ(2, output);
+    EXPECT_EQ(3, turns);
+}
+
+TEST(StateTest, Transactions)
+{
+    Group g;
+
+    StateVar<int> st( g, 1 );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& v)
+        {
+            ++turns;
+            output += v;
+        }, st);
+
+    EXPECT_EQ(1, output);
+
+    g.DoTransaction([&]
+        {
+            st.Set(1);
+            st.Set(2);
+            st.Set(3);
+            st.Set(4);
+        });
+
+    EXPECT_EQ(5, output);
+    EXPECT_EQ(2, turns);
+}
+
+TEST(StateTest, Links)
+{
+    Group g1;
+    Group g2;
+    Group g3;
+
+    StateVar<int> st1( g1, 1 );
+    StateVar<int> st2( g2, 2 );
+    StateVar<int> st3( g3, 3 );
+
+    StateSlot<int> slot( g1, st1 );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& v)
+        {
+            ++turns;
+            output = v;
+        }, slot);
+
+    EXPECT_EQ(1, turns);
+    st1.Set(10);
+    EXPECT_EQ(10, output);
+    EXPECT_EQ(2, turns);
+
+    // Explicit link
+    StateLink<int> lnk2( g1, st2 );
+    slot.Set(lnk2);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(2, output);
+    EXPECT_EQ(3, turns);
+
+    st2.Set(20);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(20, output);
+    EXPECT_EQ(4, turns);
+
+    // Implicit link
+    slot.Set(st3);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(3, output);
+    EXPECT_EQ(5, turns);
+
+    st3.Set(30);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    EXPECT_EQ(30, output);
+    EXPECT_EQ(6, turns);
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}
+
+template <typename T>
+static T Sum2(T a, T b)
+{
+    return a + b;
+}
+
+template <typename T>
+static T Sum3(T a, T b, T c)
+{
+    return a + b + c;
+}
+
+TEST(StateTest, StateCombination)
+{
+    Group g;
+
+    StateVar<int> a( g, 0 );
+    StateVar<int> b( g, 0 );
+    StateVar<int> c( g, 0 );
+
+    State<int> s1(Sum2<int>, a, b);
+    
+    State<int> x(Sum2<int>, s1, c);
+    State<int> y(Sum3<int>, a, b, c);
+
+    int output1 = 0;
+    int output2 = 0;
+    int turns1 = 0;
+    int turns2 = 0;
+
+    Observer obs1([&] (int v)
+        {
+            ++turns1;
+            output1 = v;
+        }, x);
+
+    EXPECT_EQ(0, output1);
+    EXPECT_EQ(1, turns1);
+
+    Observer obs2([&] (int v)
+        {
+            ++turns2;
+            output2 = v;
+        }, y);
+
+    EXPECT_EQ(0, output2);
+    EXPECT_EQ(1, turns2);
+
+    a.Set(1);
+    b.Set(1);
+    c.Set(1);
+
+    EXPECT_EQ(3, output1);
+    EXPECT_EQ(4, turns1);
+
+    EXPECT_EQ(3, output2);
+    EXPECT_EQ(4, turns2);
+}
\ No newline at end of file
diff --git a/tests/src/transaction_tests.cpp b/tests/src/transaction_tests.cpp
new file mode 100644
index 00000000..33812c75
--- /dev/null
+++ b/tests/src/transaction_tests.cpp
@@ -0,0 +1,220 @@
+
+//          Copyright Sebastian Jeckel 2017.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include "gtest/gtest.h"
+
+#include "react/event.h"
+#include "react/observer.h"
+
+#include <thread>
+#include <chrono>
+
+using namespace react;
+
+TEST(TransactionTests, Merging)
+{
+    Group g;
+
+    EventSource<int> evt( g );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& events)
+        {
+            ++turns;
+            for (int e : events)
+                output += e;
+        }, evt);
+
+    // This transaction blocks the queue for one second.
+    g.EnqueueTransaction([&]
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        });
+
+    SyncPoint sp;
+
+    // Enqueue 3 more transaction while the queue is blocked.
+    // They should be merged together as a result.
+    g.EnqueueTransaction([&]
+        {
+            evt.Emit(1);
+            evt.Emit(2);
+        }, sp, TransactionFlags::allow_merging);
+
+    g.EnqueueTransaction([&]
+        {
+            evt.Emit(3);
+            evt.Emit(4);
+        }, sp, TransactionFlags::allow_merging);
+
+    g.EnqueueTransaction([&]
+        {
+            evt.Emit(5);
+            evt.Emit(6);
+        }, sp, TransactionFlags::allow_merging);
+
+    bool done = sp.WaitFor(std::chrono::seconds(3));
+    EXPECT_EQ(true, done);
+
+    // They have been merged, there should only be a single turn.
+    EXPECT_EQ(1, turns);
+
+    // None of the emitted values have been lost.
+    EXPECT_EQ(21, output);
+}
+
+TEST(TransactionTests, LinkedSync)
+{
+    // Three groups. Each has one event with an observer attached.
+    // The last observer adds a little delay.
+
+    Group g1;
+    Group g2;
+    Group g3;
+
+    EventSource<int> evt1( g1 );
+
+    int output1 = 0;
+    int turns1 = 0;
+
+    Observer obs1([&] (const auto& events)
+        {
+            ++turns1;
+            for (int e : events)
+                output1 += e;
+        }, evt1);
+
+    Event<int> evt2 = Filter(g2, [] (const auto&) { return true; }, evt1);
+
+    int output2 = 0;
+    int turns2 = 0;
+
+    Observer obs2([&] (const auto& events)
+        {
+            ++turns2;
+            for (int e : events)
+                output2 += e;
+        }, evt2);
+
+    Event<int> evt3 = Filter(g3, [] (const auto&) { return true; }, evt2);
+
+    int output3 = 0;
+    int turns3 = 0;
+
+    Observer obs3([&] (const auto& events)
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+
+            ++turns3;
+            for (int e : events)
+                output3 += e;
+        }, evt3);
+
+    SyncPoint sp;
+
+    // Enqueue a transaction that waits on linked nodes.
+    g1.EnqueueTransaction([&]
+        {
+            evt1.Emit(1);
+            evt1.Emit(2);
+        }, sp, TransactionFlags::sync_linked);
+
+    // We should wait for all three observers.
+    bool done = sp.WaitFor(std::chrono::seconds(3));
+
+    EXPECT_EQ(true, done);
+
+    EXPECT_EQ(1, turns1);
+    EXPECT_EQ(1, turns2);
+    EXPECT_EQ(1, turns3);
+
+    EXPECT_EQ(3, output1);
+    EXPECT_EQ(3, output2);
+    EXPECT_EQ(3, output3);
+}
+
+TEST(TransactionTests, LinkedSyncMerging)
+{
+    // Two groups. Each has one event with an observer attached.
+    // The last observer adds a little delay.
+
+    Group g1;
+    Group g2;
+
+    EventSource<int> evt1( g1 );
+
+    int output1 = 0;
+    int turns1 = 0;
+
+    Observer obs1([&] (const auto& events)
+        {
+            ++turns1;
+            for (int e : events)
+                output1 += e;
+        }, evt1);
+
+    Event<int> evt2 = Filter(g2, [] (const auto&) { return true; }, evt1);
+
+    int output2 = 0;
+    int turns2 = 0;
+
+    Observer obs2([&] (const auto& events)
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+
+            ++turns2;
+            for (int e : events)
+                output2 += e;
+        }, evt2);
+
+    SyncPoint sp1;
+    SyncPoint sp2;
+
+    // This transaction blocks the queue for one second.
+    g1.EnqueueTransaction([&]
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        });
+
+    // Two more transactions are enqueued using two different sync points.
+    // The first one should only sync on obs1, not on linked nodes.
+    g1.EnqueueTransaction([&]
+        {
+            evt1.Emit(1);
+            evt1.Emit(2);
+        }, sp1, TransactionFlags::allow_merging);
+
+    // The second one should sync on obs2 as well. 
+    g1.EnqueueTransaction([&]
+        {
+            evt1.Emit(3);
+            evt1.Emit(4);
+        }, sp2, TransactionFlags::allow_merging | TransactionFlags::sync_linked);
+
+    // Should be done after obs1 is done with both transactions (because they have been merged).
+    bool done = sp1.WaitFor(std::chrono::seconds(5));
+
+    EXPECT_EQ(true, done);
+
+    EXPECT_EQ(1, turns1);
+    EXPECT_EQ(0, turns2);
+
+    EXPECT_EQ(10, output1);
+    EXPECT_EQ(0, output2);
+
+    // Should be done after obs2 is done.
+    done = sp2.WaitFor(std::chrono::seconds(5));
+
+    EXPECT_EQ(true, done);
+
+    EXPECT_EQ(1, turns1);
+    EXPECT_EQ(1, turns2);
+
+    EXPECT_EQ(10, output1);
+    EXPECT_EQ(10, output2);
+}
\ No newline at end of file

From 238e09e0e73f58290487b43d481cb6592b49b8f3 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Tue, 24 Oct 2017 23:51:13 +0200
Subject: [PATCH 54/75] EventLinkNode cleanup.

---
 include/react/detail/event_nodes.h | 41 +++++++++++++-----------------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/include/react/detail/event_nodes.h b/include/react/detail/event_nodes.h
index f422a903..dfec7020 100644
--- a/include/react/detail/event_nodes.h
+++ b/include/react/detail/event_nodes.h
@@ -424,13 +424,23 @@ class EventLinkNode : public EventNode<E>
 public:
     EventLinkNode(const Group& group, const Event<E>& dep) :
         EventLinkNode::EventNode( group ),
-        linkOutput_( dep )
+        dep_( dep ),
+        srcGroup_( dep.GetGroup() )
     {
         this->RegisterMe(NodeCategory::input);
+
+        auto& srcGraphPtr = GetInternals(srcGroup_).GetGraphPtr();
+        outputNodeId_ = srcGraphPtr->RegisterNode(&linkOutput_, NodeCategory::linkoutput);
+        
+        srcGraphPtr->AttachNode(outputNodeId_, GetInternals(dep).GetNodeId());
     }
 
     ~EventLinkNode()
     {
+        auto& srcGraphPtr = GetInternals(srcGroup_).GetGraphPtr();
+        srcGraphPtr->DetachNode(outputNodeId_, GetInternals(dep_).GetNodeId());
+        srcGraphPtr->UnregisterNode(outputNodeId_);
+
         auto& linkCache = GetGraphPtr()->GetLinkCache();
         linkCache.Erase(this);
 
@@ -449,23 +459,6 @@ class EventLinkNode : public EventNode<E>
 private:
     struct VirtualOutputNode : public IReactNode
     {
-        VirtualOutputNode(const Event<E>& depIn) :
-            parent( ),
-            dep( depIn ),
-            srcGroup( depIn.GetGroup() )
-        {
-            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
-            nodeId = srcGraphPtr->RegisterNode(this, NodeCategory::linkoutput);
-            srcGraphPtr->AttachNode(nodeId, GetInternals(dep).GetNodeId());
-        }
-
-        ~VirtualOutputNode()
-        {
-            auto& srcGraphPtr = GetInternals(srcGroup).GetGraphPtr();
-            srcGraphPtr->DetachNode(nodeId, GetInternals(dep).GetNodeId());
-            srcGraphPtr->UnregisterNode(nodeId);
-        }
-
         virtual UpdateResult Update(TurnId turnId) noexcept override
             { return UpdateResult::changed; }
 
@@ -475,7 +468,7 @@ class EventLinkNode : public EventNode<E>
             {
                 auto* rawPtr = p->GetGraphPtr().get();
                 output[rawPtr].push_back(
-                    [storedParent = std::move(p), storedEvents = GetInternals(dep).Events()] () mutable
+                    [storedParent = std::move(p), storedEvents = GetInternals(p->dep_).Events()] () mutable
                     {
                         NodeId nodeId = storedParent->GetNodeId();
                         auto& graphPtr = storedParent->GetGraphPtr();
@@ -489,13 +482,13 @@ class EventLinkNode : public EventNode<E>
             }
         }
 
-        std::weak_ptr<EventLinkNode> parent;
-
-        NodeId      nodeId;
-        Event<E>    dep;
-        Group       srcGroup;
+        std::weak_ptr<EventLinkNode> parent;  
     };
 
+    Event<E>    dep_;
+    Group       srcGroup_;
+    NodeId      outputNodeId_;
+
     VirtualOutputNode linkOutput_;
 };
 

From 5a9912825d442d5d3ffd0fc09a79408fc6f75d60 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Tue, 24 Oct 2017 23:57:06 +0200
Subject: [PATCH 55/75] Renamed and deleted files.

---
 include/react/{Algorithm.h => algorithm.h} |   0
 include/react/{API.h => api.h}             |   0
 include/react/common/RefCounting.h         | 112 -------
 include/react/common/SourceIdSet.h         | 135 ---------
 include/react/common/Timing.h              | 201 -------------
 include/react/common/TopoQueue.h           | 332 ---------------------
 include/react/common/Types.h               |  31 --
 include/react/common/expected.h            | 218 --------------
 include/react/common/optional.h            |  70 -----
 include/react/common/owned_ptr.h           |  18 --
 include/react/detail/{Defs.h => defs.h}    |   0
 include/react/{Event.h => event.h}         |   0
 include/react/{Group.h => group.h}         |   0
 include/react/{Observer.h => observer.h}   |   0
 14 files changed, 1117 deletions(-)
 rename include/react/{Algorithm.h => algorithm.h} (100%)
 rename include/react/{API.h => api.h} (100%)
 delete mode 100644 include/react/common/RefCounting.h
 delete mode 100644 include/react/common/SourceIdSet.h
 delete mode 100644 include/react/common/Timing.h
 delete mode 100644 include/react/common/TopoQueue.h
 delete mode 100644 include/react/common/Types.h
 delete mode 100644 include/react/common/expected.h
 delete mode 100644 include/react/common/optional.h
 delete mode 100644 include/react/common/owned_ptr.h
 rename include/react/detail/{Defs.h => defs.h} (100%)
 rename include/react/{Event.h => event.h} (100%)
 rename include/react/{Group.h => group.h} (100%)
 rename include/react/{Observer.h => observer.h} (100%)

diff --git a/include/react/Algorithm.h b/include/react/algorithm.h
similarity index 100%
rename from include/react/Algorithm.h
rename to include/react/algorithm.h
diff --git a/include/react/API.h b/include/react/api.h
similarity index 100%
rename from include/react/API.h
rename to include/react/api.h
diff --git a/include/react/common/RefCounting.h b/include/react/common/RefCounting.h
deleted file mode 100644
index 37bb5e68..00000000
--- a/include/react/common/RefCounting.h
+++ /dev/null
@@ -1,112 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_REF_COUNTING_H_INCLUDED
-#define REACT_COMMON_REF_COUNTING_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/defs.h"
-
-#include <condition_variable>
-#include <mutex>
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-// A non-exception-safe pointer wrapper with conditional intrusive ref counting.
-template <typename T>
-class IntrusiveRefCountingPtr
-{
-    enum
-    {
-        tag_ref_counted = 0x1
-    };
-
-public:
-    IntrusiveRefCountingPtr() :
-        ptrData_( reinterpret_cast<uintptr_t>(nullptr) )
-    {}
-
-    IntrusiveRefCountingPtr(T* ptr) :
-        ptrData_( reinterpret_cast<uintptr_t>(ptr) )
-    {
-        if (ptr != nullptr && ptr->IsRefCounted())
-        {
-            ptr->IncRefCount();
-            ptrData_ |= tag_ref_counted;
-        }
-    }
-
-    IntrusiveRefCountingPtr(const IntrusiveRefCountingPtr& other) :
-        ptrData_( other.ptrData_ )
-    {
-        if (isValidRefCountedPtr())
-            Get()->IncRefCount();
-    }
-
-    IntrusiveRefCountingPtr(IntrusiveRefCountingPtr&& other) :
-        ptrData_( other.ptrData_ )
-    {
-        other.ptrData_ = reinterpret_cast<uintptr_t>(nullptr);
-    }
-
-    ~IntrusiveRefCountingPtr()
-    {
-        if (isValidRefCountedPtr())
-            Get()->DecRefCount();
-    }
-
-    IntrusiveRefCountingPtr& operator=(const IntrusiveRefCountingPtr& other)
-    {
-        if (this != &other)
-        {
-            if (other.isValidRefCountedPtr())
-                other.Get()->IncRefCount();
-
-            if (isValidRefCountedPtr())
-                Get()->DecRefCount();
-
-            ptrData_ = other.ptrData_;
-        }
-
-        return *this;
-    }
-
-    IntrusiveRefCountingPtr& operator=(IntrusiveRefCountingPtr&& other)
-    {
-        if (this != &other)
-        {
-            if (isValidRefCountedPtr())
-                Get()->DecRefCount();
-
-            ptrData_ = other.ptrData_;
-            other.ptrData_ = reinterpret_cast<uintptr_t>(nullptr);
-        }
-
-        return *this;
-    }
-
-    T* Get() const          { return reinterpret_cast<T*>(ptrData_ & ~tag_ref_counted); }
-
-    T& operator*() const    { return *Get(); }
-    T* operator->() const   { return Get(); }
-
-    bool operator==(const IntrusiveRefCountingPtr& other) const { return Get() == other.Get(); }
-    bool operator!=(const IntrusiveRefCountingPtr& other) const { return !(*this == other); }
-
-private:
-    bool isValidRefCountedPtr() const
-    {
-        return ptrData_ != reinterpret_cast<uintptr_t>(nullptr)
-            && (ptrData_ & tag_ref_counted) != 0;
-    }
-
-    uintptr_t   ptrData_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_COMMON_REF_COUNTING_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/SourceIdSet.h b/include/react/common/SourceIdSet.h
deleted file mode 100644
index 902a39aa..00000000
--- a/include/react/common/SourceIdSet.h
+++ /dev/null
@@ -1,135 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_SOURCEIDSET_H_INCLUDED
-#define REACT_COMMON_SOURCEIDSET_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/defs.h"
-
-#include <algorithm>
-#include <vector>
-
-#include "tbb/queuing_mutex.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SourceIdSet
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class SourceIdSet
-{
-private:
-    using MutexT    = tbb::queuing_mutex;
-    using DataT     = std::vector<T>;
-
-public:
-    void Insert(const T& e)
-    {
-        MutexT::scoped_lock lock(mutex_);
-
-        data_.push_back(e);
-        
-        isSorted_ = false;
-    }
-
-    void Insert(SourceIdSet<T>& other)
-    {
-        MutexT::scoped_lock myLock(mutex_);
-        MutexT::scoped_lock otherLock(other.mutex_);
-
-        sort();
-        other.sort();
-
-        auto l = data_.begin();
-        auto r = data_.end();
-        auto offset = std::distance(l,r);
-
-        // For each element in other, check if it's already contained in this
-        // if not, add it
-        for (const auto& e : other.data_)
-        {
-            l = std::lower_bound(l, r, e);
-
-            // Already in the set?
-            if (l < r && *l == e)
-                continue;
-
-            auto d = std::distance(data_.begin(), l);
-
-            data_.push_back(e);
-
-            // push_back invalidates iterators
-            l = data_.begin() + d;
-            r = data_.begin() + offset; 
-        }
-
-        std::inplace_merge(data_.begin(), data_.begin() + offset, data_.end());
-    }
-
-    void Erase(const T& e)
-    {
-        MutexT::scoped_lock lock(mutex_);
-
-        data_.erase(std::find(data_.begin(), data_.end(), e));
-    }
-
-    void Clear()
-    {
-        MutexT::scoped_lock lock(mutex_);
-
-        data_.clear();
-        isSorted_ = true;
-    }
-
-    bool IntersectsWith(SourceIdSet<T>& other)
-    {
-        MutexT::scoped_lock myLock(mutex_);
-        MutexT::scoped_lock otherLock(other.mutex_);
-
-        sort();
-        other.sort();
-
-        auto l1 = data_.begin();
-        const auto r1 = data_.end();
-
-        auto l2 = other.data_.begin();
-        const auto r2 = other.data_.end();
-
-        // Is intersection of turn sourceIds and node sourceIds non-empty?
-        while (l1 != r1 && l2 != r2)
-        {
-            if (*l1 < *l2)
-                l1++;
-            else if (*l2 < *l1)
-                l2++;
-            // Equals => Intersect 
-            else
-                return true;
-        }
-        return false;
-    }
-
-private:
-    MutexT  mutex_;
-    DataT   data_;
-    bool    isSorted_ = false;
-
-    void sort()
-    {
-        if (isSorted_)
-            return;
-        
-        std::sort(data_.begin(), data_.end());
-        isSorted_ = true;
-    }
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_COMMON_SOURCEIDSET_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/Timing.h b/include/react/common/Timing.h
deleted file mode 100644
index 7d6c81ac..00000000
--- a/include/react/common/Timing.h
+++ /dev/null
@@ -1,201 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_TIMING_H_INCLUDED
-#define REACT_COMMON_TIMING_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/defs.h"
-
-#include <utility>
-
-#if _WIN32 || _WIN64
-    #define REACT_FIXME_CUSTOM_TIMER 1
-#else
-    #define REACT_FIXME_CUSTOM_TIMER 0
-#endif
-
-#if REACT_FIXME_CUSTOM_TIMER
-    #include <windows.h>
-#else
-    #include <chrono>
-#endif
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// GetPerformanceFrequency
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Todo: Initialization not thread-safe
-#if REACT_FIXME_CUSTOM_TIMER
-inline const LARGE_INTEGER& GetPerformanceFrequency()
-{
-    static bool init = false;
-    static LARGE_INTEGER frequency;
-
-    if (init == false)
-    {
-        QueryPerformanceFrequency(&frequency);
-        init = true;
-    }
-
-    return frequency;
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ConditionalTimer
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    long long threshold,
-    bool is_enabled
->
-class ConditionalTimer
-{
-public:
-    class ScopedTimer
-    {
-    public:
-        // Note:
-        // Count is passed by ref so it can be set later if it's not known at time of creation
-        ScopedTimer(const ConditionalTimer&, const size_t& count);
-    };
-
-    void Reset();
-    void ForceThresholdExceeded(bool isExceeded);
-    bool IsThresholdExceeded() const;
-};
-
-// Disabled
-template
-<
-    long long threshold
->
-class ConditionalTimer<threshold,false>
-{
-public:
-    // Defines scoped timer that does nothing
-    class ScopedTimer
-    {
-    public:
-        ScopedTimer(const ConditionalTimer&, const size_t& count) {}
-    };
-
-    void Reset()                                    {}
-    void ForceThresholdExceeded(bool isExceeded)    {}
-    bool IsThresholdExceeded() const                { return false; }
-};
-
-// Enabled
-template
-<
-    long long threshold
->
-class ConditionalTimer<threshold,true>
-{
-public:
-#if REACT_FIXME_CUSTOM_TIMER
-    using TimestampT = LARGE_INTEGER;
-#else
-    using ClockT = std::chrono::high_resolution_clock;
-    using TimestampT = std::chrono::time_point<ClockT>;
-#endif
-
-    class ScopedTimer
-    {
-    public:
-        ScopedTimer(ConditionalTimer& parent, const size_t& count) :
-            parent_( parent ),
-            count_( count )
-        {
-            if (!parent_.shouldMeasure_)
-                return;
-
-            startMeasure();
-        }
-
-        ~ScopedTimer()
-        {
-            if (!parent_.shouldMeasure_)
-                return;
-
-            parent_.shouldMeasure_ = false;
-            
-            endMeasure();
-        }
-
-    private:
-        void startMeasure()
-        {
-            startTime_ = now();
-        }
-
-        void endMeasure()
-        {
-#if REACT_FIXME_CUSTOM_TIMER
-            TimestampT endTime = now();
-
-            LARGE_INTEGER durationUS;
-
-            durationUS.QuadPart = endTime.QuadPart - startTime_.QuadPart;
-            durationUS.QuadPart *= 1000000;
-            durationUS.QuadPart /= GetPerformanceFrequency().QuadPart;
-
-            parent_.isThresholdExceeded_ = (durationUS.QuadPart - (threshold * count_)) > 0;
-#else
-            using std::chrono::duration_cast;
-            using std::chrono::microseconds;
-
-            parent_.isThresholdExceeded_ =
-                duration_cast<microseconds>(now() - startTime_).count() > (threshold * count_);
-#endif
-        }
-
-        ConditionalTimer&   parent_;
-        TimestampT          startTime_;  
-        const size_t&       count_;
-    };
-
-    static TimestampT now()
-    {
-#if REACT_FIXME_CUSTOM_TIMER
-        TimestampT result;
-        QueryPerformanceCounter(&result);
-        return result;
-#else
-        return ClockT::now();
-#endif
-    }
-
-    void Reset() 
-    {
-        shouldMeasure_ = true;
-        isThresholdExceeded_ = false;
-    }
-
-    void ForceThresholdExceeded(bool isExceeded) 
-    {
-        shouldMeasure_ = false;
-        isThresholdExceeded_ = isExceeded;
-    }
-
-    bool IsThresholdExceeded() const { return isThresholdExceeded_; }
-
-private:
-    // Only measure once
-    bool shouldMeasure_ = true;
-
-    // Until we have measured, assume the threshold is exceeded.
-    // The cost of initially not parallelizing what should be parallelized is much higher
-    // than for the other way around.
-    bool isThresholdExceeded_ = true;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_COMMON_TIMING_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/TopoQueue.h b/include/react/common/TopoQueue.h
deleted file mode 100644
index 2c3c4613..00000000
--- a/include/react/common/TopoQueue.h
+++ /dev/null
@@ -1,332 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_TOPOQUEUE_H_INCLUDED
-#define REACT_COMMON_TOPOQUEUE_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/defs.h"
-
-#include <algorithm>
-#include <array>
-#include <limits>
-#include <utility>
-#include <vector>
-
-#include "tbb/enumerable_thread_specific.h"
-#include "tbb/tbb_stddef.h"
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// TopoQueue - Sequential
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-int GetNodeLevel(const T& node)
-    { return node.level; }
-
-template <typename T>
-int GetNodeLevel(const T* node)
-    { return node->level; }
-
-template <typename T>
-class TopoQueue
-{
-private:
-    struct Entry;
-
-public:
-    // Store the level as part of the entry for cheap comparisons
-    using QueueDataT    = std::vector<Entry>;
-    using NextDataT     = std::vector<T>;
-
-    TopoQueue() = default;
-    TopoQueue(const TopoQueue&) = default;
-
-    void Push(const T& value)
-    {
-        queueData_.emplace_back(value, GetNodeLevel(value));
-    }
-
-    bool FetchNext()
-    {
-        // Throw away previous values
-        nextData_.clear();
-
-        // Find min level of nodes in queue data
-        minLevel_ = (std::numeric_limits<int>::max)();
-        for (const auto& e : queueData_)
-            if (minLevel_ > e.Level)
-                minLevel_ = e.Level;
-
-        // Swap entries with min level to the end
-        auto p = std::partition(
-            queueData_.begin(),
-            queueData_.end(),
-            [minLevel_] (const Entry& e) { return minLevel_ != e.level; });
-
-        // Reserve once to avoid multiple re-allocations
-        nextData_.reserve(std::distance(p, queueData_.end()));
-
-        // Move min level values to next data
-        for (auto it = p; it != queueData_.end(); ++it)
-            nextData_.push_back(std::move(it->Value));
-
-        // Truncate moved entries
-        queueData_.resize(std::distance(queueData_.begin(), p));
-
-        return !nextData_.empty();
-    }
-
-    const NextDataT& NextValues() const  { return nextData_; }
-
-private:
-    struct Entry
-    {
-        Entry() = default;
-        Entry(const Entry&) = default;
-
-        Entry(const T& value, int level) : Value( value ), Level( level ) {}
-
-        T       Value;
-        int     Level;
-    };
-
-    struct LevelCompFunctor
-    {
-        LevelCompFunctor(int level) : Level( level ) {}
-
-        bool operator()(const Entry& e) const { return e.Level != Level; }
-
-        const int Level;
-    };
-
-    NextDataT   nextData_;
-    QueueDataT  queueData_;
-
-    TLevelFunc  levelFunc_;
-
-    int         minLevel_ = (std::numeric_limits<int>::max)();
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// WeightedRange - Implements tbb range concept
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<
-    typename TIt,
-    uint grain_size
->
-class WeightedRange
-{
-public:
-    using const_iterator = TIt;
-    using ValueT = typename TIt::value_type;
-
-    WeightedRange() = default;
-    WeightedRange(const WeightedRange&) = default;
-
-    WeightedRange(const TIt& a, const TIt& b, uint weight) :
-        begin_( a ),
-        end_( b ),
-        weight_( weight )
-    {}
-
-    WeightedRange(WeightedRange& source, tbb::split)
-    {
-        uint sum = 0;        
-        TIt p = source.begin_;
-        while (p != source.end_)
-        {
-            // Note: assuming a pair with weight as second until more flexibility is needed
-            sum += p->second;
-            ++p;
-            if (sum >= grain_size)
-                break;
-        }
-
-        // New [p,b)
-        begin_ = p;
-        end_ = source.end_;
-        weight_ =  source.weight_ - sum;
-
-        // Source [a,p)
-        source.end_ = p;
-        source.weight_ = sum;
-    }
-
-    // tbb range interface
-    bool empty() const          { return !(Size() > 0); }
-    bool is_divisible() const   { return  weight_ > grain_size && Size() > 1; }
-
-    // iteration interface
-    const_iterator begin() const    { return begin_; }
-    const_iterator end() const      { return end_; }
-
-    size_t  Size() const    { return end_ - begin_; }
-    uint    Weight() const  { return weight_; }
-
-private:
-    TIt         begin_;
-    TIt         end_;
-    uint        weight_ = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ConcurrentTopoQueue
-/// Usage based on two phases:
-///     1. Multiple threads push nodes to the queue concurrently.
-///     2. FetchNext() prepares all nodes of the next level in NextNodes().
-///         The previous contents of NextNodes() are automatically cleared. 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template
-<   typename T,
-    uint grain_size,
-    typename TLevelFunc,
-    typename TWeightFunc
->
-class ConcurrentTopoQueue
-{
-private:
-    struct Entry;
-
-public:
-    using QueueDataT    = std::vector<Entry>;
-    using NextDataT     = std::vector<std::pair<T,uint>>;
-    using NextRangeT    = WeightedRange<typename NextDataT::const_iterator, grain_size>;
-
-    ConcurrentTopoQueue() = default;
-    ConcurrentTopoQueue(const ConcurrentTopoQueue&) = default;
-
-    template <typename FIn1, typename FIn2>
-    ConcurrentTopoQueue(FIn1&& levelFunc, FIn2&& weightFunc) :
-        levelFunc_( std::forward<FIn1>(levelFunc) ),
-        weightFunc_( std::forward<FIn2>(weightFunc) )
-    {}
-
-    void Push(const T& value)
-    {
-        auto& t = collectBuffer_.local();
-
-        auto level  = levelFunc_(value);
-        auto weight = weightFunc_(value);
-
-        t.Data.emplace_back(value,level,weight);
-
-        t.Weight += weight;
-
-        if (t.MinLevel > level)
-            t.MinLevel = level;
-    }
-
-    bool FetchNext()
-    {
-        nextData_.clear();
-        uint totalWeight = 0;
-
-        // Determine current min level
-        minLevel_ = (std::numeric_limits<int>::max)();
-        for (const auto& buf : collectBuffer_)
-            if (minLevel_ > buf.MinLevel)
-                minLevel_ = buf.MinLevel;
-
-        // For each thread local buffer...
-        for (auto& buf : collectBuffer_)
-        {
-            auto& v = buf.Data;
-
-            // Swap min level nodes to end of v
-            auto p = std::partition(
-                v.begin(),
-                v.end(),
-                LevelCompFunctor{ minLevel_ });
-
-            // Reserve once to avoid multiple re-allocations
-            nextData_.reserve(std::distance(p, v.end()));
-
-            // Move min level values to global next data
-            for (auto it = p; it != v.end(); ++it)
-                nextData_.emplace_back(std::move(it->Value), it->Weight);
-
-            // Truncate remaining
-            v.resize(std::distance(v.begin(), p));
-
-            // Calc new min level and weight for this buffer
-            buf.MinLevel = (std::numeric_limits<int>::max)();
-            int oldWeight = buf.Weight;
-            buf.Weight = 0;
-            for (const auto& x : v)
-            {
-                buf.Weight += x.Weight;
-
-                if (buf.MinLevel > x.Level)
-                    buf.MinLevel = x.Level;
-            }
-
-            // Add diff to nodes_ weight
-            totalWeight += oldWeight - buf.Weight;
-        }
-
-        nextRange_ = NextRangeT{ nextData_.begin(), nextData_.end(), totalWeight };
-
-        // Found more nodes?
-        return !nextData_.empty();
-    }
-
-    const NextRangeT& NextRange() const
-    {
-        return nextRange_;
-    }
-
-private:
-    struct Entry
-    {
-        Entry() = default;
-        Entry(const Entry&) = default;
-
-        Entry(const T& value, int level, uint weight) :
-            Value( value ),
-            Level( level ),
-            Weight( weight )
-        {}
-
-        T       Value;
-        int     Level;
-        uint    Weight;
-    };
-
-    struct LevelCompFunctor
-    {
-        LevelCompFunctor(int level) : Level{ level } {}
-
-        bool operator()(const Entry& e) const { return  e.Level != Level; }
-
-        const int Level;
-    };
-
-    struct ThreadLocalBuffer
-    {
-        QueueDataT  Data;
-        int         MinLevel = (std::numeric_limits<int>::max)();
-        uint        Weight = 0;
-    };
-
-    int         minLevel_ = (std::numeric_limits<int>::max)();
-
-    NextDataT   nextData_;
-    NextRangeT  nextRange_;
-
-    TLevelFunc  levelFunc_;
-    TWeightFunc weightFunc_;
-
-    tbb::enumerable_thread_specific<ThreadLocalBuffer>    collectBuffer_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_COMMON_TOPOQUEUE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/Types.h b/include/react/common/Types.h
deleted file mode 100644
index 30a377fa..00000000
--- a/include/react/common/Types.h
+++ /dev/null
@@ -1,31 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_TYPES_H_INCLUDED
-#define REACT_COMMON_TYPES_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/defs.h"
-
-#include <chrono>
-#include <cstdint>
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-using ObjectId = uintptr_t;
-
-template <typename O>
-ObjectId GetObjectId(const O& obj)
-{
-	return (ObjectId)&obj;
-}
-
-using UpdateDurationT = std::chrono::duration<uint, std::micro>;
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-#endif // REACT_COMMON_TYPES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/expected.h b/include/react/common/expected.h
deleted file mode 100644
index 5bdff539..00000000
--- a/include/react/common/expected.h
+++ /dev/null
@@ -1,218 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2016.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_EXPECTED_H_INCLUDED
-#define REACT_COMMON_EXPECTED_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-#include <string>
-#include <sstream>
-#include <memory>
-#include <type_traits>
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IError
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class IErrorCause
-{
-public:
-    virtual ~IErrorCause() = default;
-
-    virtual std::string GetMessage() const = 0;
-
-    virtual bool IsOfType(const char* typeId) const = 0;
-};
-
-
-class AllocationError : public IErrorCause
-{
-public:
-    static constexpr const char* type_id = "react::AllocationError";
-
-    virtual std::string GetMessage() const
-        { return "Allocation error."; }
-
-    virtual bool IsOfType(const char* typeId) const
-        { return typeId == type_id; }
-};
-
-
-class PreconditionError : public IErrorCause
-{
-public:
-    static constexpr const char* type_id = "react::PreconditionError";
-
-    virtual std::string GetMessage() const
-        { return "Precondition error."; }
-
-    virtual bool IsOfType(const char* typeId) const
-        { return typeId == type_id; }
-};
-
-
-class PostconditionError : public IErrorCause
-{
-public:
-    static constexpr const char* type_id = "react::PostconditionError";
-
-    virtual std::string GetMessage() const
-        { return "Postcondition error."; }
-
-    virtual bool IsOfType(const char* typeId) const
-        { return typeId == type_id; }
-};
-
-
-class MissingValueError : public IErrorCause
-{
-public:
-    static constexpr const char* type_id = "react::MissingValueError";
-
-    virtual std::string GetMessage() const
-        { return "Missing value error."; }
-
-    virtual bool IsOfType(const char* typeId) const
-        { return typeId == type_id; }
-};
-
-
-class Error
-{
-public:
-    template
-    <
-        typename T,
-        typename = std::enable_if_t<std::is_base_of_v<IErrorCause, T>>
-    >
-    Error(T cause) :
-        cause_(std::make_shared<T>(std::move(cause)))
-    { }
-
-    template
-    <
-        typename T,
-        typename = std::enable_if_t<std::is_base_of_v<IErrorCause, T>>
-    >
-    bool IsCause() const
-        { return cause_->IsOfType(T::type_id); }
-
-    template
-    <
-        typename T,
-        typename = std::enable_if_t<std::is_base_of_v<IErrorCause, T>>
-    >
-    T* GetCause() const
-        { return static_cast<T*>(cause_.get()); }
-
-    std::string GetMessage() const
-        { return cause_->GetMessage(); }
-
-private:
-    std::shared_ptr<const IErrorCause> cause_;
-};
-
-static Error* GetErrorSentinel()
-    { return reinterpret_cast<Error*>(0x1u); }
-
-struct ErrorDeleter
-{
-    void operator()(Error* p) const
-    {
-        if (p != GetErrorSentinel())
-            delete p;
-    }
-};
-
-using UniqueErrorPtrType = std::unique_ptr<Error, ErrorDeleter>;
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Expected
-///
-/// TODO: Optimize for different storage types to avoid branch in destructor.
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class Expected
-{
-public:
-    Expected() = delete;
-
-    Expected(const Expected&) = delete;
-
-    Expected& operator=(const Expected&) = delete;
-
-    Expected(Expected&&) = default;
-
-    Expected& operator=(Expected&&) = default;
-
-    Expected(const T& value) :
-        error_( GetErrorSentinel() )
-    {
-        ValueRef() = value;
-    }
-
-    Expected(T&& value) :
-        error_( GetErrorSentinel() )
-    {
-        ValueRef() = std::move(value);
-    }
-
-    Expected(Error err) :
-        error_(new Error(std::move(err)))
-    { }
-
-    Expected(UniqueErrorPtrType&& err) :
-        error_(std::move(err))
-    { }
-
-    ~Expected()
-    {
-        if (error_.get() == GetErrorSentinel())
-        {
-            Destruct();
-        }   
-    }
-
-    explicit operator bool() const
-    {
-        return error_.get() == GetErrorSentinel();
-    }
-
-    Error GetError()
-        { return *error_; }
-
-private:
-    const T& ValueRef() const
-        { return *reinterpret_cast<T*>(&valueStorage_); }
-
-    T& ValueRef()
-        { return *reinterpret_cast<T*>(&valueStorage_); }
-
-    void Destruct()
-        { reinterpret_cast<const T*>(&valueStorage_)->~T(); }
-
-    std::aligned_storage_t<sizeof(T)> valueStorage_;
-
-    std::unique_ptr<Error, ErrorDeleter> error_;
-
-    template <typename U>
-    friend typename UniqueErrorPtrType UnwindExpected(Expected<U>&& ex);
-};
-
-template <typename T>
-typename UniqueErrorPtrType UnwindExpected(Expected<T>&& ex)
-{
-    return std::move(std::move(ex).error_);
-}
-
-/******************************************/ REACT_END /******************************************/
-
-#endif // REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/optional.h b/include/react/common/optional.h
deleted file mode 100644
index 3208c33b..00000000
--- a/include/react/common/optional.h
+++ /dev/null
@@ -1,70 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_OPTIONAL_H_INCLUDED
-#define REACT_COMMON_OPTIONAL_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/defs.h"
-
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-
-struct NoValueType
-{
-    struct Tag {};
-
-    explicit constexpr NoValueType(Tag)
-    { }
-};
-
-constexpr NoValueType no_value{ NoValueType::Tag{ } };
-
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-template <typename T>
-class OptScalarStorage
-{
-public:
-    OptScalarStorage() : hasValue_( false )
-    { }
-
-    OptScalarStorage(NoValueType) : hasValue_( false )
-    { }
-
-    OptScalarStorage& operator=(NoValueType)
-    {
-        hasValue_ = false;
-        return *this;
-    }
-
-    OptScalarStorage(const OptScalarStorage&) = default;
-
-    OptScalarStorage& operator=(const OptScalarStorage&) = default;
-
-    bool HasValue() const
-        { return hasValue_; }
-
-    const T& Value() const
-        { return value_; }
-
-    T& Value()
-        { return value_; }
-
-private:
-    T       value_;
-    bool    hasValue_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-/******************************************/ REACT_END /******************************************/
-
-#endif // REACT_COMMON_OPTIONAL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/owned_ptr.h b/include/react/common/owned_ptr.h
deleted file mode 100644
index f0d06bcb..00000000
--- a/include/react/common/owned_ptr.h
+++ /dev/null
@@ -1,18 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef REACT_COMMON_OWNED_PTR_H_INCLUDED
-#define REACT_COMMON_OWNED_PTR_H_INCLUDED
-
-#pragma once
-
-#include "react/detail/Defs.h"
-
-/*****************************************/ REACT_BEGIN /*****************************************/
-
-/******************************************/ REACT_END /******************************************/
-
-#endif // REACT_COMMON_OWNED_PTR_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/Defs.h b/include/react/detail/defs.h
similarity index 100%
rename from include/react/detail/Defs.h
rename to include/react/detail/defs.h
diff --git a/include/react/Event.h b/include/react/event.h
similarity index 100%
rename from include/react/Event.h
rename to include/react/event.h
diff --git a/include/react/Group.h b/include/react/group.h
similarity index 100%
rename from include/react/Group.h
rename to include/react/group.h
diff --git a/include/react/Observer.h b/include/react/observer.h
similarity index 100%
rename from include/react/Observer.h
rename to include/react/observer.h

From df1bf4b7c52d6017e74b959dc2d938b952c43f8a Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 25 Oct 2017 01:32:45 +0200
Subject: [PATCH 56/75] Cleanup. Added event tests.

---
 include/react/detail/event_nodes.h            |  30 +-
 include/react/detail/graph_interface.h        |   1 -
 include/react/detail/node_base.h              |   1 -
 include/react/event.h                         |  18 +-
 project/msvc/CppReactTest.vcxproj             |   5 +-
 project/msvc/CppReactTest.vcxproj.filters     |  15 +-
 src/detail/graph_impl.cpp                     |   5 +-
 tests/src/MoveTest.h                          | 134 --------
 tests/src/ObserverTest.h                      | 242 -------------
 tests/src/OperationsTest.cpp                  |  12 -
 .../src/{MoveTest.cpp => algorithm_tests.cpp} |   0
 tests/src/event_tests.cpp                     | 323 +++++++++++++++++-
 .../{ObserverTest.cpp => observer_test.cpp}   |   0
 13 files changed, 354 insertions(+), 432 deletions(-)
 delete mode 100644 tests/src/MoveTest.h
 delete mode 100644 tests/src/ObserverTest.h
 delete mode 100644 tests/src/OperationsTest.cpp
 rename tests/src/{MoveTest.cpp => algorithm_tests.cpp} (100%)
 rename tests/src/{ObserverTest.cpp => observer_test.cpp} (100%)

diff --git a/include/react/detail/event_nodes.h b/include/react/detail/event_nodes.h
index dfec7020..d497acb3 100644
--- a/include/react/detail/event_nodes.h
+++ b/include/react/detail/event_nodes.h
@@ -121,15 +121,15 @@ class EventMergeNode : public EventNode<E>
 
     ~EventMergeNode()
     {
-        apply([this] (const auto& ... deps)
-            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(deps).GetNodeId())); }, depHolder_);
+        apply([this] (const auto& ... inputs)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(inputs).GetNodeId())); }, inputs_);
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        apply([this] (auto& ... deps)
-            { REACT_EXPAND_PACK(MergeFromDep(deps)); }, depHolder_);
+        apply([this] (auto& ... inputs)
+            { REACT_EXPAND_PACK(MergeFromInput(inputs)); }, inputs_);
 
         if (! this->Events().empty())
             return UpdateResult::changed;
@@ -141,7 +141,7 @@ class EventMergeNode : public EventNode<E>
     template <typename U>
     void MergeFromInput(Event<U>& dep)
     {
-        EventInternals& depInternals = GetInternals(dep);
+        auto& depInternals = GetInternals(dep);
         this->Events().insert(this->Events().end(), depInternals.Events().begin(), depInternals.Events().end());
     }
 
@@ -340,22 +340,23 @@ class EventJoinNode : public EventNode<std::tuple<Ts ...>>
 
     ~EventJoinNode()
     {
-        apply([this] (const auto& ... slots) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
+        apply([this] (const auto& ... slots)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(slots.source).GetNodeId())); }, slots_);
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Move events into buffers.
-        apply([this, turnId] (Slot<Ts>& ... slots) { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
+        apply([this, turnId] (Slot<Ts>& ... slots)
+            { REACT_EXPAND_PACK(FetchBuffer(turnId, slots)); }, slots_);
 
         while (true)
         {
             bool isReady = true;
 
             // All slots ready?
-            apply(
-                [this, &isReady] (Slot<Ts>& ... slots)
+            apply([this, &isReady] (Slot<Ts>& ... slots)
                 {
                     // Todo: combine return values instead
                     REACT_EXPAND_PACK(CheckSlot(slots, isReady));
@@ -366,8 +367,7 @@ class EventJoinNode : public EventNode<std::tuple<Ts ...>>
                 break;
 
             // Pop values from buffers and emit tuple.
-            apply(
-                [this] (Slot<Ts>& ... slots)
+            apply([this] (Slot<Ts>& ... slots)
                 {
                     this->Events().emplace_back(slots.buffer.front() ...);
                     REACT_EXPAND_PACK(slots.buffer.pop_front());
@@ -376,14 +376,9 @@ class EventJoinNode : public EventNode<std::tuple<Ts ...>>
         }
 
         if (! this->Events().empty())
-        {
-            this->SetPendingSuccessorCount(successorCount);
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
 private:
@@ -392,7 +387,7 @@ class EventJoinNode : public EventNode<std::tuple<Ts ...>>
     {
         Slot(const Event<U>& src) :
             source( src )
-            { }
+        { }
 
         Event<U>        source;
         std::deque<U>   buffer;
@@ -402,7 +397,6 @@ class EventJoinNode : public EventNode<std::tuple<Ts ...>>
     static void FetchBuffer(TurnId turnId, Slot<U>& slot)
     {
         slot.buffer.insert(slot.buffer.end(), GetInternals(slot.source).Events().begin(), GetInternals(slot.source).Events().end());
-        GetInternals(slot.source).DecrementPendingSuccessorCount();
     }
 
     template <typename T>
diff --git a/include/react/detail/graph_interface.h b/include/react/detail/graph_interface.h
index 6fa51f89..8d0997b3 100644
--- a/include/react/detail/graph_interface.h
+++ b/include/react/detail/graph_interface.h
@@ -17,7 +17,6 @@
 #include <utility>
 
 #include "react/api.h"
-#include "react/common/types.h"
 #include "react/common/utility.h"
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
diff --git a/include/react/detail/node_base.h b/include/react/detail/node_base.h
index 6345d431..2f0c67fd 100644
--- a/include/react/detail/node_base.h
+++ b/include/react/detail/node_base.h
@@ -15,7 +15,6 @@
 #include <memory>
 #include <utility>
 
-#include "react/common/types.h"
 #include "react/common/utility.h"
 #include "react/detail/graph_interface.h"
 
diff --git a/include/react/event.h b/include/react/event.h
index 903d3dc6..5d67c8ce 100644
--- a/include/react/event.h
+++ b/include/react/event.h
@@ -291,12 +291,14 @@ class EventLink : public Event<E>
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E, typename ... Us>
-auto Merge(const Group& group, const Event<E>& dep1, const Event<Us>& ... deps) -> decltype(auto)
+auto Merge(const Group& group, const Event<E>& dep1, const Event<Us>& ... deps) -> Event<E>
 {
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
 
-    return Event<E>::CreateWithNode<EventMergeNode<E, U1, Us ...>>(group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
+    return CreateWrappedNode<Event<E>, EventMergeNode<E, E, Us ...>>(
+        group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
 }
 
 template <typename T = void, typename U1, typename ... Us>
@@ -342,8 +344,8 @@ auto Filter(F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event
 template <typename E, typename F, typename T>
 auto Transform(const Group& group, F&& op, const Event<T>& dep) -> Event<E>
 {
-    auto transformFunc = [capturedOp = std::forward<F>(op)] (EventRange<T> inRange, EventSink<E> out)
-        { std::transform(inRange.begin(), inRange.end(), out, capturedOp); };
+    auto transformFunc = [capturedOp = std::forward<F>(op)] (const EventValueList<T>& evts, EventValueSink<E> out)
+        { std::transform(evts.begin(), evts.end(), out, capturedOp); };
 
     return Event<E>(group, std::move(transformFunc), dep);
 }
@@ -355,9 +357,9 @@ auto Transform(F&& op, const Event<T>& dep) -> Event<E>
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(const Group& group, F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
 {
-    auto transformFunc = [capturedOp = std::forward<F>(pred)] (EventRange<T> inRange, EventSink<E> out, const Vs& ... values)
+    auto transformFunc = [capturedOp = std::forward<F>(pred)] (const EventValueList<T>& evts, EventValueSink<E> out, const Us& ... values)
     {
-        for (const auto& v : inRange)
+        for (const auto& v : evts)
             *out++ = capturedPred(v, values ...);
     };
 
@@ -375,10 +377,12 @@ template <typename U1, typename ... Us>
 auto Join(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
 
     static_assert(sizeof...(Us) > 0, "Join requires at least 2 inputs.");
 
-    return Event<std::tuple<U1, Us ...>>::CreateWithNode<EventJoinNode<U1, Us ...>>(
+    return CreateWrappedNode<Event<std::tuple<U1, Us ...>>, EventJoinNode<U1, Us ...>>(
         group, SameGroupOrLink(group, dep1), SameGroupOrLink(group, deps) ...);
 }
 
diff --git a/project/msvc/CppReactTest.vcxproj b/project/msvc/CppReactTest.vcxproj
index 7516767f..eda051bb 100644
--- a/project/msvc/CppReactTest.vcxproj
+++ b/project/msvc/CppReactTest.vcxproj
@@ -164,9 +164,8 @@
   <ItemGroup>
     <ClCompile Include="..\..\tests\src\common_tests.cpp" />
     <ClCompile Include="..\..\tests\src\event_tests.cpp" />
-    <ClCompile Include="..\..\tests\src\MoveTest.cpp" />
-    <ClCompile Include="..\..\tests\src\ObserverTest.cpp" />
-    <ClCompile Include="..\..\tests\src\OperationsTest.cpp" />
+    <ClCompile Include="..\..\tests\src\observer_test.cpp" />
+    <ClCompile Include="..\..\tests\src\algorithm_tests.cpp" />
     <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp" />
     <ClCompile Include="..\..\tests\src\state_tests.cpp" />
     <ClCompile Include="..\..\tests\src\transaction_tests.cpp" />
diff --git a/project/msvc/CppReactTest.vcxproj.filters b/project/msvc/CppReactTest.vcxproj.filters
index 6004eeed..8ed9f84c 100644
--- a/project/msvc/CppReactTest.vcxproj.filters
+++ b/project/msvc/CppReactTest.vcxproj.filters
@@ -15,15 +15,6 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\tests\src\MoveTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\tests\src\ObserverTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\tests\src\OperationsTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -39,5 +30,11 @@
     <ClCompile Include="..\..\tests\src\state_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\tests\src\observer_test.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\tests\src\algorithm_tests.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/detail/graph_impl.cpp b/src/detail/graph_impl.cpp
index c6ceb6be..fb44a252 100644
--- a/src/detail/graph_impl.cpp
+++ b/src/detail/graph_impl.cpp
@@ -16,11 +16,8 @@
 #include <tbb/concurrent_queue.h>
 #include <tbb/task.h>
 
-#include "react/detail/graph_impl.h"
-
-#include "react/common/types.h"
-#include "react/common/expected.h"
 #include "react/detail/graph_interface.h"
+#include "react/detail/graph_impl.h"
 
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
diff --git a/tests/src/MoveTest.h b/tests/src/MoveTest.h
deleted file mode 100644
index 0804423a..00000000
--- a/tests/src/MoveTest.h
+++ /dev/null
@@ -1,134 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include "gtest/gtest.h"
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MoveTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class MoveTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-
-    struct Stats
-    {
-        int copyCount = 0;
-        int moveCount = 0;
-    };
-
-    struct CopyCounter
-    {
-        int v = 0;
-        Stats* stats = nullptr;
-
-        CopyCounter() = default;
-
-        CopyCounter(int x, Stats* s) :
-            v( x ),
-            stats( s )
-        {}
-
-        CopyCounter(const CopyCounter& other) :
-            v( other.v ),
-            stats( other.stats )
-        {
-            stats->copyCount++;
-        }
-
-        CopyCounter(CopyCounter&& other) :
-            v( other.v ),
-            stats( other.stats )
-        {
-            stats->moveCount++;
-        }
-
-        CopyCounter& operator=(const CopyCounter& other)
-        {
-            v = other.v;
-            stats = other.stats;
-            stats->copyCount++;
-            return *this;
-        }
-
-        CopyCounter& operator=(CopyCounter&& other)
-        {
-            v = other.v;
-            stats = other.stats;
-            stats->moveCount++;
-            return *this;
-        }
-
-        CopyCounter operator+(const CopyCounter& r) const
-        {
-            return CopyCounter{ v + r.v, stats };
-        }
-
-        bool operator==(const CopyCounter& other) const
-        {
-            return v == other.v;
-        }
-    };
-};
-
-TYPED_TEST_CASE_P(MoveTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Copy1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(MoveTest, Copy1)
-{
-    using D = typename Copy1::MyDomain;
-    using CopyCounter = typename Copy1::CopyCounter;
-    using Stats = typename Copy1::Stats;
-
-    Stats stats1;
-
-    auto a = MakeVar<D>(CopyCounter{1,&stats1});
-    auto b = MakeVar<D>(CopyCounter{10,&stats1});
-    auto c = MakeVar<D>(CopyCounter{100,&stats1});
-    auto d = MakeVar<D>(CopyCounter{1000,&stats1});
-
-    // 4x move to value_
-    // 4x copy to newValue_ (can't be unitialized for references)
-    ASSERT_EQ(stats1.copyCount, 4);
-    ASSERT_EQ(stats1.moveCount, 4);
-
-    auto x = a + b + c + d;
-
-    ASSERT_EQ(stats1.copyCount, 4);
-    ASSERT_EQ(stats1.moveCount, 7);
-    ASSERT_EQ(x().v, 1111);
-
-    a <<= CopyCounter{2,&stats1};
-
-    ASSERT_EQ(stats1.copyCount, 4);
-    ASSERT_EQ(stats1.moveCount, 10);
-    ASSERT_EQ(x().v, 1112);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    MoveTest,
-    Copy1
-);
-
-} // ~namespace
diff --git a/tests/src/ObserverTest.h b/tests/src/ObserverTest.h
deleted file mode 100644
index 559c0686..00000000
--- a/tests/src/ObserverTest.h
+++ /dev/null
@@ -1,242 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include "gtest/gtest.h"
-
-#include <vector>
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObserverTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class ObserverTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-};
-
-TYPED_TEST_CASE_P(ObserverTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Detach test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(ObserverTest, Detach)
-{
-    using D = typename Detach::MyDomain;
-
-    auto a1 = MakeVar<D>(1);
-    auto a2 = MakeVar<D>(1);
-
-    auto result = a1 + a2;
-
-    int observeCount1 = 0;
-    int observeCount2 = 0;
-    int observeCount3 = 0;
-
-    int phase;
-
-    auto obs1 = Observe(result, [&] (int v)
-    {
-        observeCount1++;
-
-        if (phase == 0)
-            ASSERT_EQ(v,3);
-        else if (phase == 1)
-            ASSERT_EQ(v,4);
-        else
-            ASSERT_TRUE(false);
-    });
-
-    auto obs2 = Observe(result, [&] (int v)
-    {
-        observeCount2++;
-
-        if (phase == 0)
-            ASSERT_EQ(v,3);
-        else if (phase == 1)
-            ASSERT_EQ(v,4);
-        else
-            ASSERT_TRUE(false);
-    });
-
-    auto obs3 = Observe(result, [&] (int v)
-    {
-        observeCount3++;
-
-        if (phase == 0)
-            ASSERT_EQ(v,3);
-        else if (phase == 1)
-            ASSERT_EQ(v,4);
-        else
-            ASSERT_TRUE(false);
-    });
-
-    phase = 0;
-    a1 <<= 2;
-    ASSERT_EQ(observeCount1,1);
-    ASSERT_EQ(observeCount2,1);
-    ASSERT_EQ(observeCount3,1);
-
-    phase = 1;
-    obs1.Detach();
-    a1 <<= 3;
-    ASSERT_EQ(observeCount1,1);
-    ASSERT_EQ(observeCount2,2);
-    ASSERT_EQ(observeCount3,2);
-
-    phase = 2;
-    obs2.Detach();
-    obs3.Detach();
-    a1 <<= 4;
-    ASSERT_EQ(observeCount1,1);
-    ASSERT_EQ(observeCount2,2);
-    ASSERT_EQ(observeCount3,2);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ScopedObserver test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(ObserverTest, ScopedObserverTest)
-{
-    using D = typename ScopedObserverTest::MyDomain;
-
-    std::vector<int> results;
-
-    auto in = MakeVar<D>(1);
-
-    {
-        ScopedObserver<D> obs = Observe(in, [&] (int v) {
-            results.push_back(v);
-        });
-
-        in <<=2;
-    }
-
-    in <<=3;
-
-    ASSERT_EQ(results.size(),1);
-    ASSERT_EQ(results[0], 2);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Synced Observe test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(ObserverTest, SyncedObserveTest)
-{
-    using D = typename SyncedObserveTest::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto sum  = in1 + in2;
-    auto prod = in1 * in2;
-    auto diff = in1 - in2;
-
-    auto src1 = MakeEventSource<D>();
-    auto src2 = MakeEventSource<D,int>();
-
-    Observe(src1, With(sum,prod,diff), [] (Token, int sum, int prod, int diff) {
-        ASSERT_EQ(sum, 33);
-        ASSERT_EQ(prod, 242);
-        ASSERT_EQ(diff, 11);
-    });
-
-    Observe(src2, With(sum,prod,diff), [] (int e, int sum, int prod, int diff) {
-        ASSERT_EQ(e, 42);
-        ASSERT_EQ(sum, 33);
-        ASSERT_EQ(prod, 242);
-        ASSERT_EQ(diff, 11);
-    });
-
-    in1 <<= 22;
-    in2 <<= 11;
-
-    src1.Emit();
-    src2.Emit(42);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DetachThisObserver1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(ObserverTest, DetachThisObserver1)
-{
-    using D = typename DetachThisObserver1::MyDomain;
-
-    auto src = MakeEventSource<D>();
-
-    int count = 0;
-
-    Observe(src, [&] (Token) -> ObserverAction {
-        ++count;
-        return ObserverAction::stop_and_detach;
-    });
-
-    src.Emit();
-    src.Emit();
-
-    printf("Count %d\n", count);
-    ASSERT_EQ(count, 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// DetachThisObserver2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(ObserverTest, DetachThisObserver2)
-{
-    using D = typename DetachThisObserver2::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto sum  = in1 + in2;
-    auto prod = in1 * in2;
-    auto diff = in1 - in2;
-
-    auto src = MakeEventSource<D>();
-
-    int count = 0;
-
-    Observe(src, With(sum,prod,diff), [&] (Token, int sum, int prod, int diff) -> ObserverAction {
-        ++count;
-        return ObserverAction::stop_and_detach;
-    });
-
-    in1 <<= 22;
-    in2 <<= 11;
-
-    src.Emit();
-    src.Emit();
-
-    ASSERT_EQ(count, 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    ObserverTest,
-    Detach,
-    ScopedObserverTest,
-    SyncedObserveTest,
-    DetachThisObserver1,
-    DetachThisObserver2
-);
-
-} // ~namespace
diff --git a/tests/src/OperationsTest.cpp b/tests/src/OperationsTest.cpp
deleted file mode 100644
index 6054092a..00000000
--- a/tests/src/OperationsTest.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/MoveTest.cpp b/tests/src/algorithm_tests.cpp
similarity index 100%
rename from tests/src/MoveTest.cpp
rename to tests/src/algorithm_tests.cpp
diff --git a/tests/src/event_tests.cpp b/tests/src/event_tests.cpp
index 31565b87..98d27bfc 100644
--- a/tests/src/event_tests.cpp
+++ b/tests/src/event_tests.cpp
@@ -9,8 +9,12 @@
 #include "react/event.h"
 #include "react/observer.h"
 
-#include <thread>
+#include <algorithm>
 #include <chrono>
+#include <queue>
+#include <string>
+#include <thread>
+#include <tuple>
 
 using namespace react;
 
@@ -216,4 +220,321 @@ TEST(EventTest, Links)
 
     EXPECT_EQ(3, output);
     EXPECT_EQ(3, turns);
+}
+
+TEST(EventTest, EventSources)
+{
+    Group g;
+
+    EventSource<int> es1( g );
+    EventSource<int> es2( g );
+
+    std::queue<int> results1;
+    std::queue<int> results2;
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (int e : events)
+                results1.push(e);
+        }, es1);
+
+    Observer obs2([&] (const auto& events)
+        {
+            for (int e : events)
+                results2.push(e);
+        }, es2);
+
+    es1.Emit(10);
+    es1.Emit(20);
+    es1.Emit(30);
+
+    es2.Emit(40);
+    es2.Emit(50);
+    es2.Emit(60);
+
+    // First batch.
+    EXPECT_FALSE(results1.empty());
+    EXPECT_EQ(results1.front(), 10);
+    results1.pop();
+
+    EXPECT_FALSE(results1.empty());
+    EXPECT_EQ(results1.front(), 20);
+    results1.pop();
+
+    EXPECT_FALSE(results1.empty());
+    EXPECT_EQ(results1.front(),30);
+    results1.pop();
+
+    EXPECT_TRUE(results1.empty());
+
+    // Second batch.
+    EXPECT_FALSE(results2.empty());
+    EXPECT_EQ(results2.front(),40);
+    results2.pop();
+
+    EXPECT_FALSE(results2.empty());
+    EXPECT_EQ(results2.front(),50);
+    results2.pop();
+
+    EXPECT_FALSE(results2.empty());
+    EXPECT_EQ(results2.front(),60);
+    results2.pop();
+    
+    EXPECT_TRUE(results2.empty());
+}
+
+TEST(EventTest, Merge1)
+{
+    Group g;
+
+    EventSource<int> a1( g );
+    EventSource<int> a2( g );
+    EventSource<int> a3( g );
+
+    Event<int> merged = Merge(g, a1, a2, a3);
+
+    std::vector<int> results;
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (int e : events)
+                results.push_back(e);
+        }, merged);
+
+    g.DoTransaction([&]
+        {
+            a1.Emit(10);
+            a2.Emit(20);
+            a3.Emit(30);
+        });
+
+    EXPECT_EQ(results.size(), 3);
+
+    EXPECT_TRUE(std::find(results.begin(), results.end(), 10) != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), 20) != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), 30) != results.end());
+}
+
+TEST(EventTest, Merge2)
+{
+    Group g;
+
+    EventSource<std::string> a1( g );
+    EventSource<std::string> a2( g );
+    EventSource<std::string> a3( g );
+
+    Event<std::string> merged = Merge(a1, a2, a3);
+
+    std::vector<std::string> results;
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (const auto& e : events)
+                results.push_back(e);
+        }, merged);
+
+    std::string s1("one");
+    std::string s2("two");
+    std::string s3("three");
+
+    g.DoTransaction([&]
+        {
+            a1.Emit(s1);
+            a2.Emit(s2);
+            a3.Emit(s3);
+        });
+
+    EXPECT_EQ(results.size(), 3);
+
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "one") != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "two") != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "three") != results.end());
+}
+
+TEST(EventTest, Merge3)
+{
+    Group g;
+
+    EventSource<int> a1( g );
+    EventSource<int> a2( g );
+
+    Event<int> f1 = Filter([] (int v) { return true; }, a1);
+    Event<int> f2 = Filter([] (int v) { return true; }, a2);
+
+    Event<int> merged = Merge(f1, f2);
+
+    std::queue<int> results;
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (int e : events)
+                results.push(e);
+        }, merged);
+
+    a1.Emit(10);
+    a2.Emit(20);
+    a1.Emit(30);
+
+    EXPECT_FALSE(results.empty());
+    EXPECT_EQ(results.front(), 10);
+    results.pop();
+
+    EXPECT_FALSE(results.empty());
+    EXPECT_EQ(results.front(), 20);
+    results.pop();
+
+    EXPECT_FALSE(results.empty());
+    EXPECT_EQ(results.front(), 30);
+    results.pop();
+
+    EXPECT_TRUE(results.empty());
+}
+
+TEST(EventTest, Filter)
+{
+    Group g;
+
+    EventSource<std::string> in( g );
+
+    std::queue<std::string> results;
+
+    Event<std::string> filtered = Filter(g, [] (const std::string& s)
+        {
+            return s == "Hello World";
+        }, in);
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (const auto& e : events)
+                results.push(e);
+        }, filtered);
+
+    in.Emit(std::string("Hello Worlt"));
+    in.Emit(std::string("Hello World"));
+    in.Emit(std::string("Hello Vorld"));
+
+    EXPECT_FALSE(results.empty());
+    EXPECT_EQ(results.front(), "Hello World");
+    results.pop();
+
+    EXPECT_TRUE(results.empty());
+}
+
+TEST(EventTest, Transform)
+{
+    Group g;
+
+    EventSource<std::string> in1( g );
+    EventSource<std::string> in2( g );
+
+    std::vector<std::string> results;
+
+    Event<std::string> merged = Merge(in1, in2);
+
+    Event<std::string> transformed = Transform<std::string>([] (std::string s) -> std::string
+        {
+            std::transform(s.begin(), s.end(), s.begin(), ::toupper);
+            return s;
+        }, merged);
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (const auto& e : events)
+                results.push_back(e);
+        }, transformed);
+
+    in1.Emit(std::string("Hello Worlt"));
+    in1.Emit(std::string("Hello World"));
+    in2.Emit(std::string("Hello Vorld"));
+
+    EXPECT_EQ(results.size(), 3);
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLT") != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLD") != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD") != results.end());
+}
+
+TEST(EventTest, Chain)
+{
+    Group g;
+
+    std::vector<float> results;
+
+    EventSource<int> in1( g );
+    EventSource<int> in2( g );
+
+    auto merged = Merge(in1, in2);
+    int turns = 0;
+
+    Event<float> processed([&] (const auto& events, auto out)
+        {
+            for (const auto& e : events)
+            {
+                *out = 0.1f * e;
+                *out = 1.5f * e;
+            }
+
+            ++turns;
+        }, merged);
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (float e : events)
+                results.push_back(e);
+        }, processed);
+
+    g.DoTransaction([&] {
+        in1.Emit(10);
+        in1.Emit(20);
+    });
+
+    in2 << 30;
+
+    EXPECT_EQ(results.size(), 6);
+    EXPECT_EQ(turns, 2);
+
+    EXPECT_EQ(results[0], 1.0f);
+    EXPECT_EQ(results[1], 15.0f);
+    EXPECT_EQ(results[2], 2.0f);
+    EXPECT_EQ(results[3], 30.0f);
+    EXPECT_EQ(results[4], 3.0f);
+    EXPECT_EQ(results[5], 45.0f);
+}
+
+TEST(EventTest, Join)
+{
+    Group g;
+
+    EventSource<int> in1( g );
+    EventSource<int> in2( g );
+    EventSource<int> in3( g );
+
+    Event<std::tuple<int, int, int>> joined = Join(in1, in2, in3);
+
+    std::vector<std::tuple<int, int, int>> results;
+
+    Observer obs1([&] (const auto& events)
+        {
+            for (const auto& e : events)
+                results.push_back(e);
+        }, joined);
+
+    in1.Emit(10);
+    EXPECT_EQ(results.size(), 0);
+
+    in2.Emit(10);
+    EXPECT_EQ(results.size(), 0);
+
+    in2.Emit(20);
+    EXPECT_EQ(results.size(), 0);
+
+    in3.Emit(10);
+    EXPECT_EQ(results.size(), 1);
+    EXPECT_EQ(results[0], std::make_tuple(10, 10, 10));
+
+    in3.Emit(20);
+    EXPECT_EQ(results.size(), 1);
+
+    in1.Emit(20);
+    EXPECT_EQ(results.size(), 2);
+    EXPECT_EQ(results[1], std::make_tuple(20, 20, 20));
 }
\ No newline at end of file
diff --git a/tests/src/ObserverTest.cpp b/tests/src/observer_test.cpp
similarity index 100%
rename from tests/src/ObserverTest.cpp
rename to tests/src/observer_test.cpp

From 55fbe9b961784f7820cb63e62e2b1c66842e84a5 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 26 Oct 2017 00:44:34 +0200
Subject: [PATCH 57/75] Removed obsolete files. Added more tests.

---
 include/react/algorithm.h                 |  10 +-
 include/react/api.h                       |   2 +
 include/react/detail/algorithm_nodes.h    |  62 +-
 include/react/detail/event_nodes.h        |  16 +-
 include/react/detail/state_nodes.h        |   2 +-
 include/react/event.h                     |  43 +-
 project/msvc/CppReactTest.vcxproj         |   1 -
 project/msvc/CppReactTest.vcxproj.filters |   3 -
 tests/src/EventStreamTest.h               | 335 --------
 tests/src/EventStreamTestQ.cpp            |  29 -
 tests/src/ObserverTestQ.cpp               |  29 -
 tests/src/OperationsTest.h                | 971 ----------------------
 tests/src/OperationsTestQ.cpp             |  29 -
 tests/src/ParallelizationTest.cpp         |  12 -
 tests/src/ParallelizationTest.h           |  63 --
 tests/src/SignalTest.h                    | 664 ---------------
 tests/src/SignalTestQ.cpp                 |  29 -
 tests/src/TestUtil.h                      |  25 -
 tests/src/TransactionTest.h               | 571 -------------
 tests/src/algorithm_tests.cpp             | 708 +++++++++++++++-
 tests/src/event_tests.cpp                 | 149 +++-
 tests/src/state_tests.cpp                 | 167 +++-
 tests/src/transaction_tests.cpp           |   7 +-
 23 files changed, 1065 insertions(+), 2862 deletions(-)
 delete mode 100644 tests/src/EventStreamTest.h
 delete mode 100644 tests/src/EventStreamTestQ.cpp
 delete mode 100644 tests/src/ObserverTestQ.cpp
 delete mode 100644 tests/src/OperationsTest.h
 delete mode 100644 tests/src/OperationsTestQ.cpp
 delete mode 100644 tests/src/ParallelizationTest.cpp
 delete mode 100644 tests/src/ParallelizationTest.h
 delete mode 100644 tests/src/SignalTest.h
 delete mode 100644 tests/src/SignalTestQ.cpp
 delete mode 100644 tests/src/TestUtil.h
 delete mode 100644 tests/src/TransactionTest.h

diff --git a/include/react/algorithm.h b/include/react/algorithm.h
index 9c1b2023..075f3d3c 100644
--- a/include/react/algorithm.h
+++ b/include/react/algorithm.h
@@ -15,12 +15,12 @@
 #include <type_traits>
 #include <utility>
 
-#include "react/API.h"
-#include "react/detail/algorithm_nodes.h"
-
+#include "react/api.h"
 #include "react/state.h"
 #include "react/event.h"
 
+#include "react/detail/algorithm_nodes.h"
+
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -66,7 +66,6 @@ template <typename S, typename T, typename F, typename E>
 auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
 {
     using REACT_IMPL::IterateNode;
-    using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
@@ -80,7 +79,6 @@ template <typename S, typename T, typename F, typename E>
 auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
 {
     using REACT_IMPL::IterateByRefNode;
-    using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
@@ -105,7 +103,6 @@ template <typename S, typename T, typename F, typename E, typename ... Us>
 auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const State<Us>& ... states) -> State<S>
 {
     using REACT_IMPL::SyncedIterateNode;
-    using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
@@ -119,7 +116,6 @@ template <typename S, typename T, typename F, typename E, typename ... Us>
 auto IterateByRef(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt, const State<Us>& ... states) -> State<S>
 {
     using REACT_IMPL::SyncedIterateByRefNode;
-    using REACT_IMPL::IsCallableWith;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
diff --git a/include/react/api.h b/include/react/api.h
index 89ace35c..d8d15204 100644
--- a/include/react/api.h
+++ b/include/react/api.h
@@ -33,6 +33,8 @@ enum class TransactionFlags
 
 REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
 
+enum class Token { value };
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// API types
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/algorithm_nodes.h b/include/react/detail/algorithm_nodes.h
index b0a7d9da..968080d5 100644
--- a/include/react/detail/algorithm_nodes.h
+++ b/include/react/detail/algorithm_nodes.h
@@ -44,7 +44,7 @@ class IterateNode : public StateNode<S>
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        S newValue = func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value());
+        S newValue = func_(GetInternals(evnt_).Events(), this->Value());
 
         if (! (newValue == this->Value()))
         {
@@ -81,15 +81,15 @@ class IterateByRefNode : public StateNode<S>
 
     ~IterateByRefNode()
     {
-        this->DetachFromMe(GetInternals(evnt).GetNodeId());
+        this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value());
+        func_(GetInternals(evnt_).Events(), this->Value());
 
-        // Always assume change
+        // Always assume a change
         return UpdateResult::changed;
     }
 
@@ -119,7 +119,8 @@ class SyncedIterateNode : public StateNode<S>
 
     ~SyncedIterateNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        apply([this] (const auto& ... syncs)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
         this->DetachFromMe(GetInternals(evnt_).GetNodeId());
         this->UnregisterMe();
     }
@@ -130,12 +131,10 @@ class SyncedIterateNode : public StateNode<S>
         if (GetInternals(evnt_).Events().empty())
             return UpdateResult::unchanged;
 
-        S newValue = apply(
-            [this] (const auto& ... syncs)
+        S newValue = apply([this] (const auto& ... syncs)
             {
-                return func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(syncs).Value() ...);
-            },
-            syncHolder_);
+                return func_(GetInternals(evnt_).Events(), this->Value(), GetInternals(syncs).Value() ...);
+            }, syncHolder_);
 
         if (! (newValue == this->Value()))
         {
@@ -190,7 +189,7 @@ class SyncedIterateByRefNode : public StateNode<S>
         apply(
             [this] (const auto& ... args)
             {
-                func_(EventRange<E>( GetInternals(evnt_).Events() ), this->Value(), GetInternals(args).Value() ...);
+                func_(GetInternals(evnt_).Events(), this->Value(), GetInternals(args).Value() ...);
             },
             syncHolder_);
 
@@ -199,7 +198,7 @@ class SyncedIterateByRefNode : public StateNode<S>
 
 private:
     F           func_;
-    Event<E>    events_;
+    Event<E>    evnt_;
 
     std::tuple<State<TSyncs> ...> syncHolder_;
 };
@@ -305,75 +304,70 @@ class SnapshotNode : public StateNode<S>
 /// MonitorNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-class MonitorNode : public EventStreamNode<S>
+class MonitorNode : public EventNode<S>
 {
 public:
-    MonitorNode(const Group& group, const State<S>& target) :
-        MonitorNode::EventStreamNode( group ),
-        target_( target )
+    MonitorNode(const Group& group, const State<S>& input) :
+        MonitorNode::EventNode( group ),
+        input_( input )
     {
         this->RegisterMe();
-        this->AttachToMe(GetInternals(target).GetNodeId());
+        this->AttachToMe(GetInternals(input_).GetNodeId());
     }
 
     ~MonitorNode()
     {
-        this->DetachFromMe(GetInternals(target_).GetNodeId());
+        this->DetachFromMe(GetInternals(input_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        this->Events().push_back(GetInternals(target_).Value());
-
+        this->Events().push_back(GetInternals(input_).Value());
         return UpdateResult::changed;
     }
 
 private:
-    State<S>    target_;
+    State<S>    input_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// PulseNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename E>
-class PulseNode : public EventStreamNode<S>
+class PulseNode : public EventNode<S>
 {
 public:
-    PulseNode(const Group& group, const State<S>& target, const Event<E>& trigger) :
-        PulseNode::EventStreamNode( group ),
-        target_( target ),
+    PulseNode(const Group& group, const State<S>& input, const Event<E>& trigger) :
+        PulseNode::EventNode( group ),
+        input_( input ),
         trigger_( trigger )
     {
         this->RegisterMe();
-        this->AttachToMe(GetInternals(target).GetNodeId());
+        this->AttachToMe(GetInternals(input).GetNodeId());
         this->AttachToMe(GetInternals(trigger).GetNodeId());
     }
 
     ~PulseNode()
     {
         this->DetachFromMe(GetInternals(trigger_).GetNodeId());
-        this->DetachFromMe(GetInternals(target_).GetNodeId());
+        this->DetachFromMe(GetInternals(input_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
-        for (size_t i = 0; i < GetInternals(trigger_).Events().size(); i++)
-            this->Events().push_back(GetInternals(target_).Value());
+        for (size_t i = 0; i < GetInternals(trigger_).Events().size(); ++i)
+            this->Events().push_back(GetInternals(input_).Value());
 
         if (! this->Events().empty())
-        {
             return UpdateResult::changed;
-        }
         else
-        {
             return UpdateResult::unchanged;
-        }
     }
 
 private:
-    State<S>    target_;
+    State<S>    input_;
     Event<E>    trigger_;
 };
 
diff --git a/include/react/detail/event_nodes.h b/include/react/detail/event_nodes.h
index d497acb3..7c988b23 100644
--- a/include/react/detail/event_nodes.h
+++ b/include/react/detail/event_nodes.h
@@ -285,27 +285,27 @@ class SyncedEventProcessingNode : public EventNode<TOut>
         syncHolder_( syncs ... )
     {
         this->RegisterMe();
-        this->AttachToMe(dep->GetNodeId());
-        REACT_EXPAND_PACK(this->AttachToMe(syncs->GetNodeId()));
+        this->AttachToMe(GetInternals(dep).GetNodeId());
+        REACT_EXPAND_PACK(this->AttachToMe(GetInternals(syncs).GetNodeId()));
     }
 
     ~SyncedEventProcessingNode()
     {
-        apply([this] (const auto& ... syncs) { REACT_EXPAND_PACK(this->DetachFromMe(syncs->GetNodeId())); }, syncHolder_);
-        this->DetachFromMe(dep_->GetNodeId());
+        apply([this] (const auto& ... syncs)
+            { REACT_EXPAND_PACK(this->DetachFromMe(GetInternals(syncs).GetNodeId())); }, syncHolder_);
+        this->DetachFromMe(GetInternals(dep_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
         // Updates might be triggered even if only sync nodes changed. Ignore those.
-        if (dep_->Events().empty())
+        if (GetInternals(dep_).Events().empty())
             return UpdateResult::unchanged;
 
-        apply(
-            [this] (const auto& ... syncs)
+        apply([this] (const auto& ... syncs)
             {
-                func_(EventRange<TIn>( this->dep_->Events() ), std::back_inserter(this->Events()), syncs->Value() ...);
+                func_(GetInternals(dep_).Events(), std::back_inserter(this->Events()), GetInternals(syncs).Value() ...);
             },
             syncHolder_);
 
diff --git a/include/react/detail/state_nodes.h b/include/react/detail/state_nodes.h
index 655ab542..c3b717b2 100644
--- a/include/react/detail/state_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -261,7 +261,7 @@ class StateSlotNode : public StateNode<S>
             { return UpdateResult::changed; }
     };
 
-    State<S>           input_;
+    State<S>            input_;
     NodeId              inputNodeId_;
     VirtualInputNode    slotInput_;
     
diff --git a/include/react/event.h b/include/react/event.h
index 5d67c8ce..ecde17b2 100644
--- a/include/react/event.h
+++ b/include/react/event.h
@@ -10,17 +10,17 @@
 #pragma once
 
 #include "react/detail/defs.h"
-#include "react/api.h"
-#include "react/group.h"
-#include "react/common/ptrcache.h"
 
 #include <memory>
 #include <type_traits>
 #include <utility>
 
-#include "react/detail/event_nodes.h"
+#include "react/api.h"
+#include "react/group.h"
 
+#include "react/detail/event_nodes.h"
 
+#include "react/common/ptrcache.h"
 
 /*****************************************/ REACT_BEGIN /*****************************************/
 
@@ -136,12 +136,12 @@ class EventSource : public Event<E>
     void Emit(E&& value)
         { EmitValue(std::move(value)); }
 
-    template <typename T = E, typename = std::enable_if_t<std::is_same_v<T,Token>>::type>
+    template <typename T = E, typename = std::enable_if_t<std::is_same_v<T, Token>>>
     void Emit()
         { EmitValue(Token::value); }
 
     EventSource& operator<<(const E& value)
-        { EmitValue(e); return *this; }
+        { EmitValue(value); return *this; }
 
     EventSource& operator<<(E&& value)
         { EmitValue(std::move(value)); return *this; }
@@ -311,8 +311,8 @@ auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
 template <typename F, typename E>
 auto Filter(const Group& group, F&& pred, const Event<E>& dep) -> Event<E>
 {
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out)
-        { std::copy_if(evts.begin(), evts.end(), out, capturedPred); };
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& events, EventValueSink<E> out)
+        { std::copy_if(events.begin(), events.end(), out, capturedPred); };
 
     return Event<E>(group, std::move(filterFunc), dep);
 }
@@ -324,19 +324,19 @@ auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
 template <typename F, typename E, typename ... Ts>
 auto Filter(const Group& group, F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
 {
-    auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out, const Us& ... values)
+    auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out, const Ts& ... values)
     {
         for (const auto& v : evts)
             if (capturedPred(v, values ...))
                 *out++ = v;
     };
 
-    return Event<E>(group, std::move(filterFunc), dep, State ...);
+    return Event<E>(group, std::move(filterFunc), dep, states ...);
 }
 
 template <typename F, typename E, typename ... Ts>
 auto Filter(F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
-    { return Filter(dep.GetGroup(), std::forward<F>(pred), dep); }
+    { return Filter(dep.GetGroup(), std::forward<F>(pred), dep, states ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Transform
@@ -357,10 +357,10 @@ auto Transform(F&& op, const Event<T>& dep) -> Event<E>
 template <typename E, typename F, typename T, typename ... Us>
 auto Transform(const Group& group, F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
 {
-    auto transformFunc = [capturedOp = std::forward<F>(pred)] (const EventValueList<T>& evts, EventValueSink<E> out, const Us& ... values)
+    auto transformFunc = [capturedOp = std::forward<F>(op)] (const EventValueList<T>& evts, EventValueSink<E> out, const Us& ... values)
     {
         for (const auto& v : evts)
-            *out++ = capturedPred(v, values ...);
+            *out++ = capturedOp(v, values ...);
     };
 
     return Event<E>(group, std::move(transformFunc), dep, states ...);
@@ -390,23 +390,6 @@ template <typename U1, typename ... Us>
 auto Join(const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
     { return Join(dep1.GetGroup(), dep1, deps ...); }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Token
-///////////////////////////////////////////////////////////////////////////////////////////////////
-enum class Token { value };
-
-/*struct Tokenizer
-{
-    template <typename T>
-    Token operator()(const T&) const { return Token::value; }
-};
-
-template <typename T>
-auto Tokenize(T&& source) -> decltype(auto)
-{
-    return Transform(source, Tokenizer{ });
-}*/
-
 /******************************************/ REACT_END /******************************************/
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
diff --git a/project/msvc/CppReactTest.vcxproj b/project/msvc/CppReactTest.vcxproj
index eda051bb..9cecab98 100644
--- a/project/msvc/CppReactTest.vcxproj
+++ b/project/msvc/CppReactTest.vcxproj
@@ -166,7 +166,6 @@
     <ClCompile Include="..\..\tests\src\event_tests.cpp" />
     <ClCompile Include="..\..\tests\src\observer_test.cpp" />
     <ClCompile Include="..\..\tests\src\algorithm_tests.cpp" />
-    <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp" />
     <ClCompile Include="..\..\tests\src\state_tests.cpp" />
     <ClCompile Include="..\..\tests\src\transaction_tests.cpp" />
   </ItemGroup>
diff --git a/project/msvc/CppReactTest.vcxproj.filters b/project/msvc/CppReactTest.vcxproj.filters
index 8ed9f84c..d60eac41 100644
--- a/project/msvc/CppReactTest.vcxproj.filters
+++ b/project/msvc/CppReactTest.vcxproj.filters
@@ -15,9 +15,6 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\tests\src\ParallelizationTest.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\tests\src\event_tests.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
diff --git a/tests/src/EventStreamTest.h b/tests/src/EventStreamTest.h
deleted file mode 100644
index db12a8ea..00000000
--- a/tests/src/EventStreamTest.h
+++ /dev/null
@@ -1,335 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include <queue>
-#include <string>
-
-#include "gtest/gtest.h"
-
-#include "react/Domain.h"
-#include "react/Event.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventStreamTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class EventStreamTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-};
-
-TYPED_TEST_CASE_P(EventStreamTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventSources test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventSources)
-{
-    using D = typename EventSources::MyDomain;
-
-    auto es1 = MakeEventSource<D,int>();
-    auto es2 = MakeEventSource<D,int>();
-
-    std::queue<int> results1;
-    std::queue<int> results2;
-
-    Observe(es1, [&] (int v)
-    {
-        results1.push(v);
-    });
-
-    Observe(es2, [&] (int v)
-    {
-        results2.push(v);
-    });
-
-    es1 << 10 << 20 << 30;
-    es2 << 40 << 50 << 60;
-
-    // 1
-    ASSERT_FALSE(results1.empty());
-    ASSERT_EQ(results1.front(),10);
-    results1.pop();
-
-    ASSERT_FALSE(results1.empty());
-    ASSERT_EQ(results1.front(),20);
-    results1.pop();
-
-    ASSERT_FALSE(results1.empty());
-    ASSERT_EQ(results1.front(),30);
-    results1.pop();
-
-    ASSERT_TRUE(results1.empty());
-
-    // 2
-    ASSERT_FALSE(results2.empty());
-    ASSERT_EQ(results2.front(),40);
-    results2.pop();
-
-    ASSERT_FALSE(results2.empty());
-    ASSERT_EQ(results2.front(),50);
-    results2.pop();
-
-    ASSERT_FALSE(results2.empty());
-    ASSERT_EQ(results2.front(),60);
-    results2.pop();
-    
-    ASSERT_TRUE(results2.empty());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventMerge1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventMerge1)
-{
-    using D = typename EventMerge1::MyDomain;
-
-    auto a1 = MakeEventSource<D,int>();
-    auto a2 = MakeEventSource<D,int>();
-    auto a3 = MakeEventSource<D,int>();
-
-    auto merged = Merge(a1, a2, a3);
-
-    std::vector<int> results;
-
-    Observe(merged, [&] (int v)
-    {
-        results.push_back(v);
-    });
-    
-    DoTransaction<D>([&] {
-        a1 << 10;
-        a2 << 20;
-        a3 << 30;
-    });
-
-    ASSERT_EQ(results.size(), 3);
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 10) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 20) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 30) != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventMerge2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventMerge2)
-{
-    using D = typename EventMerge2::MyDomain;
-
-    auto a1 = MakeEventSource<D,std::string>();
-    auto a2 = MakeEventSource<D,std::string>();
-    auto a3 = MakeEventSource<D,std::string>();
-
-    auto merged = Merge(a1, a2, a3);
-
-    std::vector<std::string> results;
-
-    Observe(merged, [&] (std::string s)
-    {
-        results.push_back(s);
-    });
-
-    std::string s1("one");
-    std::string s2("two");
-    std::string s3("three");
-
-    DoTransaction<D>([&] {
-        a1 << s1;
-        a2 << s2;
-        a3 << s3;
-    });
-
-    ASSERT_EQ(results.size(), 3);
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "one") != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "two") != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "three") != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventMerge3 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventMerge3)
-{
-    using D = typename EventMerge3::MyDomain;
-
-    auto a1 = MakeEventSource<D,int>();
-    auto a2 = MakeEventSource<D,int>();
-
-    auto f1 = Filter(a1, [] (int v) { return true; });
-    auto f2 = Filter(a2, [] (int v) { return true; });
-
-    auto merged = Merge(f1, f2);
-
-    std::queue<int> results;
-
-    Observe(merged, [&] (int s)
-    {
-        results.push(s);
-    });
-
-    a1 << 10;
-    a2 << 20;
-    a1 << 30;
-
-    ASSERT_FALSE(results.empty());
-    ASSERT_EQ(results.front(),10);
-    results.pop();
-
-    ASSERT_FALSE(results.empty());
-    ASSERT_EQ(results.front(),20);
-    results.pop();
-
-    ASSERT_FALSE(results.empty());
-    ASSERT_EQ(results.front(),30);
-    results.pop();
-
-    ASSERT_TRUE(results.empty());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventFilter test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventFilter)
-{
-    using D = typename EventFilter::MyDomain;
-
-    using std::string;
-
-    std::queue<string> results;
-
-    auto in = MakeEventSource<D,string>();
-
-    auto filtered = Filter(in, [] (const string& s)
-    {
-        return s == "Hello World";
-    });
-
-
-    Observe(filtered, [&] (const string& s)
-    {
-        results.push(s);
-    });
-
-    in << string("Hello Worlt") << string("Hello World") << string("Hello Vorld");
-
-    ASSERT_FALSE(results.empty());
-    ASSERT_EQ(results.front(), "Hello World");
-    results.pop();
-
-    ASSERT_TRUE(results.empty());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventTransform test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventTransform)
-{
-    using D = typename EventTransform::MyDomain;
-
-    using std::string;
-
-    std::vector<string> results;
-
-    auto in1 = MakeEventSource<D,string>();
-    auto in2 = MakeEventSource<D,string>();
-
-    auto merged = Merge(in1, in2);
-
-    auto transformed = Transform(merged, [] (string s) -> string
-    {
-        std::transform(s.begin(), s.end(), s.begin(), ::toupper);
-        return s;
-    });
-
-    Observe(transformed, [&] (const string& s)
-    {
-        results.push_back(s);
-    });
-
-    in1 << string("Hello Worlt") << string("Hello World");
-    in2 << string("Hello Vorld");
-
-    ASSERT_EQ(results.size(), 3);
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLT") != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLD") != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD") != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventProcess test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(EventStreamTest, EventProcess)
-{
-    using D = typename EventProcess::MyDomain;
-
-    std::vector<float> results;
-
-    auto in1 = MakeEventSource<D,int>();
-    auto in2 = MakeEventSource<D,int>();
-
-    auto merged = Merge(in1, in2);
-    int callCount = 0;
-
-    auto processed = Process<float>(merged,
-        [&] (EventRange<int> range, EventEmitter<float> out)
-        {
-            for (const auto& e : range)
-            {
-                *out = 0.1f * e;
-                *out = 1.5f * e;
-            }
-
-            callCount++;
-        });
-
-    Observe(processed,
-        [&] (float s)
-        {
-            results.push_back(s);
-        });
-
-    DoTransaction<D>([&] {
-        in1 << 10 << 20;
-    });
-
-    in2 << 30;
-
-    ASSERT_EQ(results.size(), 6);
-    ASSERT_EQ(callCount, 2);
-
-    ASSERT_EQ(results[0], 1.0f);
-    ASSERT_EQ(results[1], 15.0f);
-    ASSERT_EQ(results[2], 2.0f);
-    ASSERT_EQ(results[3], 30.0f);
-    ASSERT_EQ(results[4], 3.0f);
-    ASSERT_EQ(results[5], 45.0f);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    EventStreamTest,
-    EventSources,
-    EventMerge1,
-    EventMerge2,
-    EventMerge3,
-    EventFilter,
-    EventTransform,
-    EventProcess
-);
-
-} // ~namespace
diff --git a/tests/src/EventStreamTestQ.cpp b/tests/src/EventStreamTestQ.cpp
deleted file mode 100644
index 26d07507..00000000
--- a/tests/src/EventStreamTestQ.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include "EventStreamTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-using P1 = DomainParams<sequential_concurrent,ToposortEngine>;
-using P2 = DomainParams<parallel_concurrent,ToposortEngine>;
-using P3 = DomainParams<parallel_concurrent,PulsecountEngine>;
-using P4 = DomainParams<parallel_concurrent,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposortQ, EventStreamTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposortQ, EventStreamTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(PulsecountQ, EventStreamTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(SubtreeQ, EventStreamTest, P4);
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/ObserverTestQ.cpp b/tests/src/ObserverTestQ.cpp
deleted file mode 100644
index 4dfe55f6..00000000
--- a/tests/src/ObserverTestQ.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include "ObserverTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-using P1 = DomainParams<sequential_concurrent,ToposortEngine>;
-using P2 = DomainParams<parallel_concurrent,ToposortEngine>;
-using P3 = DomainParams<parallel_concurrent,PulsecountEngine>;
-using P4 = DomainParams<parallel_concurrent,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposortQ, ObserverTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposortQ, ObserverTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(PulsecountQ, ObserverTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(SubtreeQ, ObserverTest, P4);
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/OperationsTest.h b/tests/src/OperationsTest.h
deleted file mode 100644
index c7fb6d3f..00000000
--- a/tests/src/OperationsTest.h
+++ /dev/null
@@ -1,971 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include "gtest/gtest.h"
-
-#include <queue>
-#include <string>
-#include <tuple>
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
-#include "react/Algorithm.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-using namespace std;
-
-template <typename T>
-struct Incrementer { T operator()(Token, T v) const { return v+1; } };
-
-template <typename T>
-struct Decrementer { T operator()(Token, T v) const { return v-1; } };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventStreamTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class OperationsTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-};
-
-TYPED_TEST_CASE_P(OperationsTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Iterate1)
-{
-    using D = typename Iterate1::MyDomain;
-
-    auto numSrc = MakeEventSource<D,int>();
-    auto numFold = Iterate(numSrc, 0, [] (int d, int v) {
-        return v + d;
-    });
-
-    for (auto i=1; i<=100; i++)
-    {
-        numSrc << i;
-    }
-
-    ASSERT_EQ(numFold(), 5050);
-
-    auto charSrc = MakeEventSource<D,char>();
-    auto strFold = Iterate(charSrc, string(""), [] (char c, string s) {
-        return s + c;
-    });
-
-    charSrc << 'T' << 'e' << 's' << 't';
-
-    ASSERT_EQ(strFold(), "Test");
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Iterate2)
-{
-    using D = typename Iterate2::MyDomain;
-
-    auto numSrc = MakeEventSource<D,int>();
-    auto numFold = Iterate(numSrc, 0, [] (int d, int v) {
-        return v + d;
-    });
-
-    int c = 0;
-
-    Observe(numFold, [&] (int v) {
-        c++;
-        ASSERT_EQ(v, 5050);
-    });
-
-    DoTransaction<D>([&] {
-        for (auto i=1; i<=100; i++)
-            numSrc << i;
-    });
-
-    ASSERT_EQ(numFold(), 5050);
-    ASSERT_EQ(c, 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate3 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Iterate3)
-{
-    using D = typename Iterate3::MyDomain;
-
-    auto trigger = MakeEventSource<D>();
-
-    {
-        auto inc = Iterate(trigger, 0, Incrementer<int>{});
-        for (auto i=1; i<=100; i++)
-            trigger.Emit();
-
-        ASSERT_EQ(inc(), 100);
-    }
-
-    {
-        auto dec = Iterate(trigger, 100, Decrementer<int>{});
-        for (auto i=1; i<=100; i++)
-            trigger.Emit();
-
-        ASSERT_EQ(dec(), 0);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Monitor1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Monitor1)
-{
-    using D = typename Monitor1::MyDomain;
-
-    auto target = MakeVar<D>(10);
-
-    vector<int> results;
-
-    auto filterFunc = [] (int v) {
-        return v > 10;
-    };
-
-    auto obs = Observe(Monitor(target).Filter(filterFunc), [&] (int v) {
-        results.push_back(v);
-    });
-
-    target <<= 10;
-    target <<= 20;
-    target <<= 20;
-    target <<= 10;
-
-    ASSERT_EQ(results.size(), 1);
-    ASSERT_EQ(results[0], 20);
-
-    obs.Detach();
-
-    target <<= 100;
-
-    ASSERT_EQ(results.size(), 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Hold1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Hold1)
-{
-    using D = typename Hold1::MyDomain;
-
-    auto src = MakeEventSource<D,int>();
-
-    auto h = Hold(src, 0);
-
-    ASSERT_EQ(h(), 0);
-
-    src << 10;
-
-    ASSERT_EQ(h(), 10);
-    
-    src << 20 << 30;
-
-    ASSERT_EQ(h(), 30);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Hold1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Pulse1)
-{
-    using D = typename Pulse1::MyDomain;
-
-    auto trigger = MakeEventSource<D>();
-    auto target = MakeVar<D>(10);
-
-    vector<int> results;
-
-    auto p = Pulse(trigger, target);
-
-    Observe(p, [&] (int v) {
-        results.push_back(v);
-    });
-
-    target <<= 10;
-    trigger.Emit();
-
-    ASSERT_EQ(results[0], 10);
-
-    target <<= 20;
-    trigger.Emit();
-
-    ASSERT_EQ(results[1], 20);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Snapshot1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, Snapshot1)
-{
-    using D = typename Snapshot1::MyDomain;
-
-    auto trigger = MakeEventSource<D>();
-    auto target = MakeVar<D>(10);
-
-    auto snap = Snapshot(trigger, target);
-
-    target <<= 10;
-    trigger.Emit();
-    target <<= 20;
-
-    ASSERT_EQ(snap(), 10);
-
-    target <<= 20;
-    trigger.Emit();
-    target <<= 30;
-
-    ASSERT_EQ(snap(), 20);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IterateByRef1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, IterateByRef1)
-{
-    using D = typename IterateByRef1::MyDomain;
-
-    auto src = MakeEventSource<D,int>();
-    auto f = Iterate(
-        src,
-        std::vector<int>(),
-        [] (int d, std::vector<int>& v) {
-            v.push_back(d);
-        });
-
-    // Push
-    for (auto i=1; i<=100; i++)
-        src << i;
-
-    ASSERT_EQ(f().size(), 100);
-
-    // Check
-    for (auto i=1; i<=100; i++)
-        ASSERT_EQ(f()[i-1], i);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// IterateByRef2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, IterateByRef2)
-{
-    using D = typename IterateByRef2::MyDomain;
-
-    auto src = MakeEventSource<D>();
-    auto x = Iterate(
-        src,
-        std::vector<int>(),
-        [] (Token, std::vector<int>& v) {
-            v.push_back(123);
-        });
-
-    // Push
-    for (auto i=0; i<100; i++)
-        src.Emit();
-
-    ASSERT_EQ(x().size(), 100);
-
-    // Check
-    for (auto i=0; i<100; i++)
-        ASSERT_EQ(x()[i], 123);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedTransform1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedTransform1)
-{
-    using D = typename SyncedTransform1::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto sum  = in1 + in2;
-    auto prod = in1 * in2;
-    auto diff = in1 - in2;
-
-    auto src1 = MakeEventSource<D>();
-    auto src2 = MakeEventSource<D,int>();
-
-    auto out1 = Transform(src1, With(sum,prod,diff), [] (Token, int sum, int prod, int diff) {
-        return make_tuple(sum, prod, diff);
-    });
-
-    auto out2 = Transform(src2, With(sum,prod,diff), [] (int e, int sum, int prod, int diff) {
-        return make_tuple(e, sum, prod, diff);
-    });
-
-    int obsCount1 = 0;
-    int obsCount2 = 0;
-
-    {
-        auto obs1 = Observe(out1, [&] (const tuple<int,int,int>& t) {
-            ++obsCount1;
-
-            ASSERT_EQ(get<0>(t), 33);
-            ASSERT_EQ(get<1>(t), 242);
-            ASSERT_EQ(get<2>(t), 11);
-        });
-
-        auto obs2 =  Observe(out2, [&] (const tuple<int,int,int,int>& t) {
-            ++obsCount2;
-
-            ASSERT_EQ(get<0>(t), 42);
-            ASSERT_EQ(get<1>(t), 33);
-            ASSERT_EQ(get<2>(t), 242);
-            ASSERT_EQ(get<3>(t), 11);
-        });
-
-        in1 <<= 22;
-        in2 <<= 11;
-
-        src1.Emit();
-        src2.Emit(42);
-
-        ASSERT_EQ(obsCount1, 1);
-        ASSERT_EQ(obsCount2, 1);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-
-    {
-        auto obs1 = Observe(out1, [&] (const tuple<int,int,int>& t) {
-            ++obsCount1;
-
-            ASSERT_EQ(get<0>(t), 330);
-            ASSERT_EQ(get<1>(t), 24200);
-            ASSERT_EQ(get<2>(t), 110);
-        });
-
-        auto obs2 = Observe(out2, [&] (const tuple<int,int,int,int>& t) {
-            ++obsCount2;
-
-            ASSERT_EQ(get<0>(t), 420);
-            ASSERT_EQ(get<1>(t), 330);
-            ASSERT_EQ(get<2>(t), 24200);
-            ASSERT_EQ(get<3>(t), 110);
-        });
-
-        in1 <<= 220;
-        in2 <<= 110;
-
-        src1.Emit();
-        src2.Emit(420);
-
-        ASSERT_EQ(obsCount1, 2);
-        ASSERT_EQ(obsCount2, 2);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedIterate1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedIterate1)
-{
-    using D = typename SyncedIterate1::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto op1 = in1 + in2;
-    auto op2 = (in1 + in2) * 10;
-
-    auto src1 = MakeEventSource<D>();
-    auto src2 = MakeEventSource<D,int>();
-
-    auto out1 = Iterate(
-        src1,
-        make_tuple(0,0),
-        With(op1,op2),
-        [] (Token, const tuple<int,int>& t, int op1, int op2) {
-            return make_tuple(get<0>(t) + op1, get<1>(t) + op2);
-        });
-
-    auto out2 = Iterate(
-        src2,
-        make_tuple(0,0,0),
-        With(op1,op2),
-        [] (int e, const tuple<int,int,int>& t, int op1, int op2) {
-            return make_tuple(get<0>(t) + e, get<1>(t) + op1, get<2>(t) + op2);
-        });
-
-    int obsCount1 = 0;
-    int obsCount2 = 0;
-
-    {
-        auto obs1 = Observe(out1, [&] (const tuple<int,int>& t) {
-            ++obsCount1;
-
-            ASSERT_EQ(get<0>(t), 33);
-            ASSERT_EQ(get<1>(t), 330);
-        });
-
-        auto obs2 = Observe(out2, [&] (const tuple<int,int,int>& t) {
-            ++obsCount2;
-
-            ASSERT_EQ(get<0>(t), 42);
-            ASSERT_EQ(get<1>(t), 33);
-            ASSERT_EQ(get<2>(t), 330);
-        });
-
-        in1 <<= 22;
-        in2 <<= 11;
-
-        src1.Emit();
-        src2.Emit(42);
-
-        ASSERT_EQ(obsCount1, 1);
-        ASSERT_EQ(obsCount2, 1);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-
-    {
-        auto obs1 = Observe(out1, [&] (const tuple<int,int>& t) {
-            ++obsCount1;
-
-            ASSERT_EQ(get<0>(t), 33 + 330);
-            ASSERT_EQ(get<1>(t), 330 + 3300);
-        });
-
-        auto obs2 = Observe(out2, [&] (const tuple<int,int,int>& t) {
-            ++obsCount2;
-
-            ASSERT_EQ(get<0>(t), 42 + 420);
-            ASSERT_EQ(get<1>(t), 33 + 330);
-            ASSERT_EQ(get<2>(t), 330 + 3300);
-        });
-
-        in1 <<= 220;
-        in2 <<= 110;
-
-        src1.Emit();
-        src2.Emit(420);
-
-        ASSERT_EQ(obsCount1, 2);
-        ASSERT_EQ(obsCount2, 2);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedIterate2 test (by ref)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedIterate2)
-{
-    using D = typename SyncedIterate2::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto op1 = in1 + in2;
-    auto op2 = (in1 + in2) * 10;
-
-    auto src1 = MakeEventSource<D>();
-    auto src2 = MakeEventSource<D,int>();
-
-    auto out1 = Iterate(
-        src1,
-        vector<int>{},
-        With(op1,op2),
-        [] (Token, vector<int>& v, int op1, int op2) -> void {
-            v.push_back(op1);
-            v.push_back(op2);
-        });
-
-    auto out2 = Iterate(
-        src2,
-        vector<int>{},
-        With(op1,op2),
-        [] (int e, vector<int>& v, int op1, int op2) -> void {
-            v.push_back(e);
-            v.push_back(op1);
-            v.push_back(op2);
-        });
-
-    int obsCount1 = 0;
-    int obsCount2 = 0;
-
-    {
-        auto obs1 = Observe(out1, [&] (const vector<int>& v) {
-            ++obsCount1;
-
-            ASSERT_EQ(v.size(), 2);
-
-            ASSERT_EQ(v[0], 33);
-            ASSERT_EQ(v[1], 330);
-        });
-
-        auto obs2 = Observe(out2, [&] (const vector<int>& v) {
-            ++obsCount2;
-
-            ASSERT_EQ(v.size(), 3);
-
-            ASSERT_EQ(v[0], 42);
-            ASSERT_EQ(v[1], 33);
-            ASSERT_EQ(v[2], 330);
-        });
-
-        in1 <<= 22;
-        in2 <<= 11;
-
-        src1.Emit();
-        src2.Emit(42);
-
-        ASSERT_EQ(obsCount1, 1);
-        ASSERT_EQ(obsCount2, 1);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-
-    {
-        auto obs1 = Observe(out1, [&] (const vector<int>& v) {
-            ++obsCount1;
-
-            ASSERT_EQ(v.size(), 4);
-
-            ASSERT_EQ(v[0], 33);
-            ASSERT_EQ(v[1], 330);
-            ASSERT_EQ(v[2], 330);
-            ASSERT_EQ(v[3], 3300);
-        });
-
-        auto obs2 = Observe(out2, [&] (const vector<int>& v) {
-            ++obsCount2;
-
-            ASSERT_EQ(v.size(), 6);
-
-            ASSERT_EQ(v[0], 42);
-            ASSERT_EQ(v[1], 33);
-            ASSERT_EQ(v[2], 330);
-
-            ASSERT_EQ(v[3], 420);
-            ASSERT_EQ(v[4], 330);
-            ASSERT_EQ(v[5], 3300);
-        });
-
-        in1 <<= 220;
-        in2 <<= 110;
-
-        src1.Emit();
-        src2.Emit(420);
-
-        ASSERT_EQ(obsCount1, 2);
-        ASSERT_EQ(obsCount2, 2);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedIterate3 test (event range)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedIterate3)
-{
-    using D = typename SyncedIterate3::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto op1 = in1 + in2;
-    auto op2 = (in1 + in2) * 10;
-
-    auto src1 = MakeEventSource<D>();
-    auto src2 = MakeEventSource<D,int>();
-
-    auto out1 = Iterate(
-        src1,
-        make_tuple(0,0),
-        With(op1,op2),
-        [] (EventRange<Token> range, const tuple<int,int>& t, int op1, int op2) {
-            return make_tuple(
-                get<0>(t) + (op1 * range.Size()),
-                get<1>(t) + (op2 * range.Size()));
-        });
-
-    auto out2 = Iterate(
-        src2,
-        make_tuple(0,0,0),
-        With(op1,op2),
-        [] (EventRange<int> range, const tuple<int,int,int>& t, int op1, int op2) {
-            int sum = 0;
-            for (const auto& e : range)
-                sum += e;
-
-            return make_tuple(
-                get<0>(t) + sum,
-                get<1>(t) + (op1 * range.Size()),
-                get<2>(t) + (op2 * range.Size()));
-        });
-
-    int obsCount1 = 0;
-    int obsCount2 = 0;
-
-    {
-        auto obs1 = Observe(out1, [&] (const tuple<int,int>& t) {
-            ++obsCount1;
-
-            ASSERT_EQ(get<0>(t), 33);
-            ASSERT_EQ(get<1>(t), 330);
-        });
-
-        auto obs2 = Observe(out2, [&] (const tuple<int,int,int>& t) {
-            ++obsCount2;
-
-            ASSERT_EQ(get<0>(t), 42);
-            ASSERT_EQ(get<1>(t), 33);
-            ASSERT_EQ(get<2>(t), 330);
-        });
-
-        in1 <<= 22;
-        in2 <<= 11;
-
-        src1.Emit();
-        src2.Emit(42);
-
-        ASSERT_EQ(obsCount1, 1);
-        ASSERT_EQ(obsCount2, 1);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-
-    {
-        auto obs1 = Observe(out1, [&] (const tuple<int,int>& t) {
-            ++obsCount1;
-
-            ASSERT_EQ(get<0>(t), 33 + 330);
-            ASSERT_EQ(get<1>(t), 330 + 3300);
-        });
-
-        auto obs2 = Observe(out2, [&] (const tuple<int,int,int>& t) {
-            ++obsCount2;
-
-            ASSERT_EQ(get<0>(t), 42 + 420);
-            ASSERT_EQ(get<1>(t), 33 + 330);
-            ASSERT_EQ(get<2>(t), 330 + 3300);
-        });
-
-        in1 <<= 220;
-        in2 <<= 110;
-
-        src1.Emit();
-        src2.Emit(420);
-
-        ASSERT_EQ(obsCount1, 2);
-        ASSERT_EQ(obsCount2, 2);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedIterate4 test (event range, by ref)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedIterate4)
-{
-    using D = typename SyncedIterate4::MyDomain;
-
-    auto in1 = MakeVar<D>(1);
-    auto in2 = MakeVar<D>(1);
-
-    auto op1 = in1 + in2;
-    auto op2 = (in1 + in2) * 10;
-
-    auto src1 = MakeEventSource<D>();
-    auto src2 = MakeEventSource<D,int>();
-
-    auto out1 = Iterate(
-        src1,
-        vector<int>{},
-        With(op1,op2),
-        [] (EventRange<Token> range, vector<int>& v, int op1, int op2) -> void {
-            for (const auto& e : range)
-            {
-                v.push_back(op1);
-                v.push_back(op2);
-            }
-        });
-
-    auto out2 = Iterate(
-        src2,
-        vector<int>{},
-        With(op1,op2),
-        [] (EventRange<int> range, vector<int>& v, int op1, int op2) -> void {
-            for (const auto& e : range)
-            {
-                v.push_back(e);
-                v.push_back(op1);
-                v.push_back(op2);
-            }
-        });
-
-    int obsCount1 = 0;
-    int obsCount2 = 0;
-
-    {
-        auto obs1 = Observe(out1, [&] (const vector<int>& v) {
-            ++obsCount1;
-
-            ASSERT_EQ(v.size(), 2);
-
-            ASSERT_EQ(v[0], 33);
-            ASSERT_EQ(v[1], 330);
-        });
-
-        auto obs2 = Observe(out2, [&] (const vector<int>& v) {
-            ++obsCount2;
-
-            ASSERT_EQ(v.size(), 3);
-
-            ASSERT_EQ(v[0], 42);
-            ASSERT_EQ(v[1], 33);
-            ASSERT_EQ(v[2], 330);
-        });
-
-        in1 <<= 22;
-        in2 <<= 11;
-
-        src1.Emit();
-        src2.Emit(42);
-
-        ASSERT_EQ(obsCount1, 1);
-        ASSERT_EQ(obsCount2, 1);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-
-    {
-        auto obs1 = Observe(out1, [&] (const vector<int>& v) {
-            ++obsCount1;
-
-            ASSERT_EQ(v.size(), 4);
-
-            ASSERT_EQ(v[0], 33);
-            ASSERT_EQ(v[1], 330);
-            ASSERT_EQ(v[2], 330);
-            ASSERT_EQ(v[3], 3300);
-        });
-
-        auto obs2 = Observe(out2, [&] (const vector<int>& v) {
-            ++obsCount2;
-
-            ASSERT_EQ(v.size(), 6);
-
-            ASSERT_EQ(v[0], 42);
-            ASSERT_EQ(v[1], 33);
-            ASSERT_EQ(v[2], 330);
-
-            ASSERT_EQ(v[3], 420);
-            ASSERT_EQ(v[4], 330);
-            ASSERT_EQ(v[5], 3300);
-        });
-
-        in1 <<= 220;
-        in2 <<= 110;
-
-        src1.Emit();
-        src2.Emit(420);
-
-        ASSERT_EQ(obsCount1, 2);
-        ASSERT_EQ(obsCount2, 2);
-
-        obs1.Detach();
-        obs2.Detach();
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// EventFilter1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedEventFilter1)
-{
-    using D = typename SyncedEventFilter1::MyDomain;
-
-    using std::string;
-
-    std::queue<string> results;
-
-    auto in = MakeEventSource<D,string>();
-
-    auto sig1 = MakeVar<D>(1338);
-    auto sig2 = MakeVar<D>(1336);
-
-    auto filtered = Filter(
-        in,
-        With(sig1, sig2),
-        [] (const string& s, int sig1, int sig2) {
-            return s == "Hello World" && sig1 > sig2;
-        });
-
-
-    Observe(filtered, [&] (const string& s)
-    {
-        results.push(s);
-    });
-
-    in << string("Hello Worlt") << string("Hello World") << string("Hello Vorld");
-    sig1 <<= 1335;
-    in << string("Hello Vorld");
-
-    ASSERT_FALSE(results.empty());
-    ASSERT_EQ(results.front(), "Hello World");
-    results.pop();
-
-    ASSERT_TRUE(results.empty());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedEventTransform1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedEventTransform1)
-{
-    using D = typename SyncedEventTransform1::MyDomain;
-
-    using std::string;
-
-    std::vector<string> results;
-
-    auto in1 = MakeEventSource<D,string>();
-    auto in2 = MakeEventSource<D,string>();
-
-    auto merged = Merge(in1, in2);
-
-    auto first = MakeVar<D>(string("Ace"));
-    auto last = MakeVar<D>(string("McSteele"));
-
-    auto transformed = Transform(
-        merged,
-        With(first, last),
-        [] (string s, const string& first, const string& last) -> string {
-            std::transform(s.begin(), s.end(), s.begin(), ::toupper);
-            s += string(", ") + first + string(" ") + last;
-            return s;
-        });
-
-    Observe(transformed, [&] (const string& s) {
-        results.push_back(s);
-    });
-
-    in1 << string("Hello Worlt") << string("Hello World");
-
-    DoTransaction<D>([&] {
-        in2 << string("Hello Vorld");
-        first.Set(string("Alice"));
-        last.Set(string("Anderson"));
-    });
-
-    ASSERT_EQ(results.size(), 3);
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLT, Ace McSteele") != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLD, Ace McSteele") != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD, Alice Anderson") != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncedEventProcess1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(OperationsTest, SyncedEventProcess1)
-{
-    using D = typename SyncedEventProcess1::MyDomain;
-
-    std::vector<float> results;
-
-    auto in1 = MakeEventSource<D,int>();
-    auto in2 = MakeEventSource<D,int>();
-
-    auto mult = MakeVar<D>(10);
-
-    auto merged = Merge(in1, in2);
-    int callCount = 0;
-
-    auto processed = Process<float>(merged,
-        With(mult),
-        [&] (EventRange<int> range, EventEmitter<float> out, int mult)
-        {
-            for (const auto& e : range)
-            {
-                *out = 0.1f * e * mult;
-                *out = 1.5f * e * mult;
-            }
-
-            callCount++;
-        });
-
-    Observe(processed,
-        [&] (float s)
-        {
-            results.push_back(s);
-        });
-
-    DoTransaction<D>([&] {
-        in1 << 10 << 20;
-    });
-
-    in2 << 30;
-
-    ASSERT_EQ(results.size(), 6);
-    ASSERT_EQ(callCount, 2);
-
-    ASSERT_EQ(results[0], 10.0f);
-    ASSERT_EQ(results[1], 150.0f);
-    ASSERT_EQ(results[2], 20.0f);
-    ASSERT_EQ(results[3], 300.0f);
-    ASSERT_EQ(results[4], 30.0f);
-    ASSERT_EQ(results[5], 450.0f);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    OperationsTest,
-    Iterate1,
-    Iterate2,
-    Iterate3,
-    Monitor1,
-    Hold1,
-    Pulse1,
-    Snapshot1,
-    IterateByRef1,
-    IterateByRef2,
-    SyncedTransform1,
-    SyncedIterate1,
-    SyncedIterate2,
-    SyncedIterate3,
-    SyncedIterate4,
-    SyncedEventFilter1,
-    SyncedEventTransform1,
-    SyncedEventProcess1
-);
-
-} // ~namespace
diff --git a/tests/src/OperationsTestQ.cpp b/tests/src/OperationsTestQ.cpp
deleted file mode 100644
index 576c0752..00000000
--- a/tests/src/OperationsTestQ.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include "OperationsTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-using P1 = DomainParams<sequential_concurrent,ToposortEngine>;
-using P2 = DomainParams<parallel_concurrent,ToposortEngine>;
-using P3 = DomainParams<parallel_concurrent,PulsecountEngine>;
-using P4 = DomainParams<parallel_concurrent,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposortQ, OperationsTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposortQ, OperationsTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(PulsecountQ, OperationsTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(SubtreeQ, OperationsTest, P4);
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/ParallelizationTest.cpp b/tests/src/ParallelizationTest.cpp
deleted file mode 100644
index 6054092a..00000000
--- a/tests/src/ParallelizationTest.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/ParallelizationTest.h b/tests/src/ParallelizationTest.h
deleted file mode 100644
index 145c730c..00000000
--- a/tests/src/ParallelizationTest.h
+++ /dev/null
@@ -1,63 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include "gtest/gtest.h"
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
-#include "react/Algorithm.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-using namespace std;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ParallelizationTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class ParallelizationTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-};
-
-TYPED_TEST_CASE_P(ParallelizationTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(ParallelizationTest, WeightHint1)
-{
-    using D = typename WeightHint1::MyDomain;
-
-    auto sig = MakeVar<D>(0);
-    auto evn = MakeEventSource<D,int>();
-    auto cont = MakeContinuation<D>(sig, [] (int v) {});
-    auto obs = Observe(evn, [] (int v) {});
-
-    sig.SetWeightHint(WeightHint::heavy);
-    evn.SetWeightHint(WeightHint::automatic);
-    cont.SetWeightHint(WeightHint::light);
-    obs.SetWeightHint(WeightHint::automatic);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    ParallelizationTest,
-    WeightHint1
-);
-
-} // ~namespace
diff --git a/tests/src/SignalTest.h b/tests/src/SignalTest.h
deleted file mode 100644
index 69ae81de..00000000
--- a/tests/src/SignalTest.h
+++ /dev/null
@@ -1,664 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include "gtest/gtest.h"
-
-#include <queue>
-#include <vector>
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class SignalTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-};
-
-TYPED_TEST_CASE_P(SignalTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// MakeVars test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, MakeVars)
-{
-    using D = typename MakeVars::MyDomain;
-
-    auto v1 = MakeVar<D>(1);
-    auto v2 = MakeVar<D>(2);
-    auto v3 = MakeVar<D>(3);
-    auto v4 = MakeVar<D>(4);
-
-    ASSERT_EQ(v1(),1);
-    ASSERT_EQ(v2(),2);
-    ASSERT_EQ(v3(),3);
-    ASSERT_EQ(v4(),4);
-
-    v1 <<= 10;
-    v2 <<= 20;
-    v3 <<= 30;
-    v4 <<= 40;
-
-    ASSERT_EQ(v1(),10);
-    ASSERT_EQ(v2(),20);
-    ASSERT_EQ(v3(),30);
-    ASSERT_EQ(v4(),40);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signals1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Signals1)
-{
-    using D = typename Signals1::MyDomain;
-
-    auto v1 = MakeVar<D>(1);
-    auto v2 = MakeVar<D>(2);
-    auto v3 = MakeVar<D>(3);
-    auto v4 = MakeVar<D>(4);
-
-    auto s1 = MakeSignal(With(v1,v2), [] (int a, int b) {
-        return a + b;
-    });
-
-    auto s2 = MakeSignal(With(v3,v4), [] (int a, int b) {
-        return a + b;
-    });
-
-    auto s3 = s1 + s2;
-
-    ASSERT_EQ(s1(),3);
-    ASSERT_EQ(s2(),7);
-    ASSERT_EQ(s3(),10);
-    
-    v1 <<= 10;
-    v2 <<= 20;
-    v3 <<= 30;
-    v4 <<= 40;
-
-    ASSERT_EQ(s1(),30);
-    ASSERT_EQ(s2(),70);
-    ASSERT_EQ(s3(),100);
-    
-    bool b = false;
-
-    b = IsSignal<decltype(v1)>::value;
-    ASSERT_TRUE(b);
-
-    b = IsSignal<decltype(s1)>::value;
-    ASSERT_TRUE(b);
-
-    b = IsSignal<decltype(s2)>::value;
-    ASSERT_TRUE(b);
-
-    b = IsSignal<decltype(10)>::value;
-    ASSERT_FALSE(b);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signals2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Signals2)
-{
-    using D = typename Signals2::MyDomain;
-
-    auto a1 = MakeVar<D>(1);
-    auto a2 = MakeVar<D>(1);
-    
-    auto b1 = a1 + 0;
-    auto b2 = a1 + a2;
-    auto b3 = a2 + 0;
-    
-    auto c1 = b1 + b2;
-    auto c2 = b2 + b3;
-
-    auto result = c1 + c2;
-
-    int observeCount = 0;
-
-    Observe(result, [&observeCount] (int v)
-    {
-        observeCount++;
-        if (observeCount == 1)
-            ASSERT_EQ(v,9);
-        else
-            ASSERT_EQ(v,12);
-    });
-
-    ASSERT_EQ(a1(),1);
-    ASSERT_EQ(a2(),1);
-
-    ASSERT_EQ(b1(),1);
-    ASSERT_EQ(b2(),2);
-    ASSERT_EQ(b3(),1);
-
-    ASSERT_EQ(c1(),3);
-    ASSERT_EQ(c2(),3);
-
-    ASSERT_EQ(result(),6);
-
-    a1 <<= 2;
-
-    ASSERT_EQ(observeCount,1);
-
-    ASSERT_EQ(a1(),2);
-    ASSERT_EQ(a2(),1);
-
-    ASSERT_EQ(b1(),2);
-    ASSERT_EQ(b2(),3);
-    ASSERT_EQ(b3(),1);
-
-    ASSERT_EQ(c1(),5);
-    ASSERT_EQ(c2(),4);
-
-    ASSERT_EQ(result(),9);
-
-    a2 <<= 2;
-
-    ASSERT_EQ(observeCount,2);
-
-    ASSERT_EQ(a1(),2);
-    ASSERT_EQ(a2(),2);
-
-    ASSERT_EQ(b1(),2);
-    ASSERT_EQ(b2(),4);
-    ASSERT_EQ(b3(),2);
-
-    ASSERT_EQ(c1(),6);
-    ASSERT_EQ(c2(),6);
-
-    ASSERT_EQ(result(),12);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signals3 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Signals3)
-{
-    using D = typename Signals3::MyDomain;
-
-    auto a1 = MakeVar<D>(1);
-    auto a2 = MakeVar<D>(1);
-    
-    auto b1 = a1 + 0;
-    auto b2 = a1 + a2;
-    auto b3 = a2 + 0;
-    
-    auto c1 = b1 + b2;
-    auto c2 = b2 + b3;
-
-    auto result = c1 + c2;
-
-    int observeCount = 0;
-
-    Observe(result, [&observeCount] (int v)
-    {
-        observeCount++;
-        ASSERT_EQ(v,12);
-    });
-
-    ASSERT_EQ(a1(),1);
-    ASSERT_EQ(a2(),1);
-
-    ASSERT_EQ(b1(),1);
-    ASSERT_EQ(b2(),2);
-    ASSERT_EQ(b3(),1);
-
-    ASSERT_EQ(c1(),3);
-    ASSERT_EQ(c2(),3);
-
-    ASSERT_EQ(result(),6);
-
-    DoTransaction<D>([&] {
-        a1 <<= 2;
-        a2 <<= 2;
-    });
-
-    ASSERT_EQ(observeCount,1);
-
-    ASSERT_EQ(a1(),2);
-    ASSERT_EQ(a2(),2);
-
-    ASSERT_EQ(b1(),2);
-    ASSERT_EQ(b2(),4);
-    ASSERT_EQ(b3(),2);
-
-    ASSERT_EQ(c1(),6);
-    ASSERT_EQ(c2(),6);
-
-    ASSERT_EQ(result(),12);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Signals4 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Signals4)
-{
-    using D = typename Signals4::MyDomain;
-
-    auto a1 = MakeVar<D>(1);
-    auto a2 = MakeVar<D>(1);
-    
-    auto b1 = a1 + a2;
-    auto b2 = b1 + a2;
-
-    ASSERT_EQ(a1(),1);
-    ASSERT_EQ(a2(),1);
-
-    ASSERT_EQ(b1(),2);
-    ASSERT_EQ(b2(),3);
-
-    a1 <<= 10;
-
-    ASSERT_EQ(a1(),10);
-    ASSERT_EQ(a2(),1);
-
-    ASSERT_EQ(b1(),11);
-    ASSERT_EQ(b2(),12);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// FunctionBind1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, FunctionBind1)
-{
-    using D = typename FunctionBind1::MyDomain;
-
-    auto v1 = MakeVar<D>(2);
-    auto v2 = MakeVar<D>(30);
-    auto v3 = MakeVar<D>(10);
-
-    auto signal = (v1, v2, v3) ->* [=] (int a, int b, int c) -> int
-    {
-        return a * b * c;
-    };
-
-    ASSERT_EQ(signal(),600);
-    v3 <<= 100;
-    ASSERT_EQ(signal(),6000);
-}
-
-int myfunc(int a, int b)        { return a + b; }
-float myfunc2(int a)            { return a / 2.0f; }
-float myfunc3(float a, float b) { return a * b; }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// FunctionBind2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, FunctionBind2)
-{
-    using D = typename FunctionBind2::MyDomain;
-
-    auto a = MakeVar<D>(1);
-    auto b = MakeVar<D>(1);
-    
-    auto c = ((a+b), (a+100)) ->* &myfunc;
-    auto d = c ->* &myfunc2;
-    auto e = (d,d) ->* &myfunc3;
-    auto f = -e + 100;
-
-    ASSERT_EQ(c(),103);
-    ASSERT_EQ(d(),51.5f);
-    ASSERT_EQ(e(),2652.25f);
-    ASSERT_EQ(f(),-2552.25);
-
-    a <<= 10;
-
-    ASSERT_EQ(c(),121);
-    ASSERT_EQ(d(),60.5f);
-    ASSERT_EQ(e(),3660.25f);
-    ASSERT_EQ(f(),-3560.25f);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Flatten1)
-{
-    using D = typename Flatten1::MyDomain;
-
-    auto inner1 = MakeVar<D>(123);
-    auto inner2 = MakeVar<D>(789);
-    
-    auto outer = MakeVar<D>(inner1);
-
-    auto flattened = Flatten(outer);
-
-    std::queue<int> results;
-
-    Observe(flattened, [&] (int v)
-    {
-        results.push(v);
-    });
-
-    ASSERT_TRUE(outer().Equals(inner1));
-    ASSERT_EQ(flattened(),123);
-
-    inner1 <<= 456;
-
-    ASSERT_EQ(flattened(),456);
-
-    ASSERT_EQ(results.front(), 456);
-    results.pop();
-    ASSERT_TRUE(results.empty());
-
-    outer <<= inner2;
-
-    ASSERT_TRUE(outer().Equals(inner2));
-    ASSERT_EQ(flattened(),789);
-
-    ASSERT_EQ(results.front(), 789);
-    results.pop();
-    ASSERT_TRUE(results.empty());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Flatten2)
-{
-    using D = typename Flatten2::MyDomain;
-
-    auto a0 = MakeVar<D>(100);
-    
-    auto inner1 = MakeVar<D>(200);
-
-    auto a1 = MakeVar<D>(300);
-    auto a2 = a1 + 0;
-    auto a3 = a2 + 0;
-    auto a4 = a3 + 0;
-    auto a5 = a4 + 0;
-    auto a6 = a5 + 0;
-    auto inner2 = a6 + 0;
-
-    ASSERT_EQ(inner1(),200);
-    ASSERT_EQ(inner2(),300);
-
-    auto outer = MakeVar<D>(inner1);
-
-    auto flattened = Flatten(outer);
-
-    ASSERT_EQ(flattened(), 200);
-
-    int observeCount = 0;
-
-    Observe(flattened, [&observeCount] (int v)
-    {
-        observeCount++;
-    });
-
-    auto o1 = a0 + flattened;
-    auto o2 = o1 + 0;
-    auto o3 = o2 + 0;
-    auto result = o3 + 0;
-
-    ASSERT_EQ(result(), 100 + 200);
-
-    inner1 <<= 1234;
-
-    ASSERT_EQ(result(), 100 + 1234);
-    ASSERT_EQ(observeCount, 1);
-
-    outer <<= inner2;
-
-    ASSERT_EQ(result(), 100 + 300);
-    ASSERT_EQ(observeCount, 2);
-
-    DoTransaction<D>([&] {
-        a0 <<= 5000;
-        a1 <<= 6000;
-    });
-
-    ASSERT_EQ(result(), 5000 + 6000);
-    ASSERT_EQ(observeCount, 3);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten3 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Flatten3)
-{
-    using D = typename Flatten3::MyDomain;
-
-    auto inner1 = MakeVar<D>(10);
-
-    auto a1 = MakeVar<D>(20);
-    auto a2 = a1 + 0;
-    auto a3 = a2 + 0;
-    auto inner2 = a3 + 0;
-
-    auto outer = MakeVar<D>(inner1);
-
-    auto a0 = MakeVar<D>(30);
-
-    auto flattened = Flatten(outer);
-
-    int observeCount = 0;
-
-    Observe(flattened, [&observeCount] (int v)
-    {
-        observeCount++;
-    });
-
-    auto result = flattened + a0;
-
-    ASSERT_EQ(result(), 10 + 30);
-    ASSERT_EQ(observeCount, 0);
-
-    DoTransaction<D>([&] {
-        inner1 <<= 1000;
-        a0 <<= 200000;
-        a1 <<= 50000;
-        outer <<= inner2;
-    });
-
-    ASSERT_EQ(result(), 50000 + 200000);
-    ASSERT_EQ(observeCount, 1);
-
-    DoTransaction<D>([&] {
-        a0 <<= 667;
-        a1 <<= 776;
-    });
-
-    ASSERT_EQ(result(), 776 + 667);
-    ASSERT_EQ(observeCount, 2);
-
-    DoTransaction<D>([&] {
-        inner1 <<= 999;
-        a0 <<= 888;
-    });
-
-    ASSERT_EQ(result(), 776 + 888);
-    ASSERT_EQ(observeCount, 2);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Flatten4 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Flatten4)
-{
-    using D = typename Flatten4::MyDomain;
-
-    std::vector<int> results;
-
-    auto a1 = MakeVar<D>(100);
-    auto inner1 = a1 + 0;
-
-    auto a2 = MakeVar<D>(200);
-    auto inner2 = a2;
-
-    auto a3 = MakeVar<D>(200);
-
-    auto outer = MakeVar<D>(inner1);
-
-    auto flattened = Flatten(outer);
-
-    auto result = flattened + a3;
-
-    Observe(result, [&] (int v)    {
-        results.push_back(v);
-    });
-
-    DoTransaction<D>([&] {
-        a3 <<= 400;
-        outer <<= inner2;
-    });
-
-    ASSERT_EQ(results.size(), 1);
-
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 600) != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Member1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Member1)
-{
-    using D = typename Member1::MyDomain;
-
-    auto outer = MakeVar<D>(10);
-    auto inner = MakeVar<D>(outer);
-
-    auto flattened = inner.Flatten();
-
-    Observe(flattened, [] (int v) {
-        ASSERT_EQ(v, 30);
-    });
-
-    outer <<= 30;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Modify1 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Modify1)
-{
-    using D = typename Modify1::MyDomain;
-
-    using std::vector;
-
-    auto v = MakeVar<D>(vector<int>{});
-
-    int obsCount = 0;
-
-    Observe(v, [&] (const vector<int>& v) {
-        ASSERT_EQ(v[0], 30);
-        ASSERT_EQ(v[1], 50);
-        ASSERT_EQ(v[2], 70);
-
-        obsCount++;
-    });
-    
-    v.Modify([] (vector<int>& v) {
-        v.push_back(30);
-        v.push_back(50);
-        v.push_back(70);
-    });
-
-    ASSERT_EQ(obsCount, 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Modify2 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Modify2)
-{
-    using D = typename Modify2::MyDomain;
-
-    using std::vector;
-
-    auto v = MakeVar<D>(vector<int>{});
-
-    int obsCount = 0;
-
-    Observe(v, [&] (const vector<int>& v) {
-        ASSERT_EQ(v[0], 30);
-        ASSERT_EQ(v[1], 50);
-        ASSERT_EQ(v[2], 70);
-
-        obsCount++;
-    });
-    
-    DoTransaction<D>([&] {
-        v.Modify([] (vector<int>& v) {
-            v.push_back(30);
-        });
-
-        v.Modify([] (vector<int>& v) {
-            v.push_back(50);
-        });
-
-        v.Modify([] (vector<int>& v) {
-            v.push_back(70);
-        });
-    });
-    
-
-    ASSERT_EQ(obsCount, 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Modify3 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(SignalTest, Modify3)
-{
-    using D = typename Modify3::MyDomain;
-
-    using std::vector;
-
-    auto vect = MakeVar<D>(vector<int>{});
-
-    int obsCount = 0;
-
-    Observe(vect, [&] (const vector<int>& v) {
-        ASSERT_EQ(v[0], 30);
-        ASSERT_EQ(v[1], 50);
-        ASSERT_EQ(v[2], 70);
-
-        obsCount++;
-    });
-    
-    // Also terrible
-    DoTransaction<D>([&] {
-
-        vect.Set(vector<int>{ 30, 50 });
-
-        vect.Modify([] (vector<int>& v) {
-            v.push_back(70);
-        });
-    });
-
-    ASSERT_EQ(obsCount, 1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    SignalTest,
-    MakeVars,
-    Signals1, Signals2, Signals3, Signals4,
-    FunctionBind1, FunctionBind2,
-    Flatten1, Flatten2, Flatten3, Flatten4,
-    Member1,
-    Modify1, Modify2, Modify3
-
-);
-
-} // ~namespace
diff --git a/tests/src/SignalTestQ.cpp b/tests/src/SignalTestQ.cpp
deleted file mode 100644
index d91875c7..00000000
--- a/tests/src/SignalTestQ.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include "SignalTest.h"
-#include "TestUtil.h"
-
-#include "react/engine/PulsecountEngine.h"
-#include "react/engine/ToposortEngine.h"
-#include "react/engine/SubtreeEngine.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-using P1 = DomainParams<sequential_concurrent,ToposortEngine>;
-using P2 = DomainParams<parallel_concurrent,ToposortEngine>;
-using P3 = DomainParams<parallel_concurrent,PulsecountEngine>;
-using P4 = DomainParams<parallel_concurrent,SubtreeEngine>;
-
-INSTANTIATE_TYPED_TEST_CASE_P(SeqToposortQ, SignalTest, P1);
-INSTANTIATE_TYPED_TEST_CASE_P(ParToposortQ, SignalTest, P2);
-INSTANTIATE_TYPED_TEST_CASE_P(PulsecountQ, SignalTest, P3);
-INSTANTIATE_TYPED_TEST_CASE_P(SubtreeQ, SignalTest, P4);
-
-} // ~namespace
\ No newline at end of file
diff --git a/tests/src/TestUtil.h b/tests/src/TestUtil.h
deleted file mode 100644
index 0d7b9cb6..00000000
--- a/tests/src/TestUtil.h
+++ /dev/null
@@ -1,25 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#ifndef REACT_TESTS_TESTUTIL_H_INCLUDED
-#define REACT_TESTS_TESTUTIL_H_INCLUDED
-
-template
-<
-    EDomainMode m,
-    template <EPropagationMode> class TTEngine
->
-struct DomainParams
-{
-    static const EDomainMode mode = m;
-
-    template <EPropagationMode pm>
-    using EngineT = TTEngine<pm>;
-};
-
-#endif // REACT_TESTS_TESTUTIL_H_INCLUDED
\ No newline at end of file
diff --git a/tests/src/TransactionTest.h b/tests/src/TransactionTest.h
deleted file mode 100644
index 0501a81c..00000000
--- a/tests/src/TransactionTest.h
+++ /dev/null
@@ -1,571 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2017.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#pragma once
-
-#include "gtest/gtest.h"
-
-#include <algorithm>
-#include <thread>
-#include <vector>
-
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
-#include "react/Algorithm.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace {
-
-using namespace react;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SignalTest fixture
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename TParams>
-class TransactionTest : public testing::Test
-{
-public:
-    template <EPropagationMode mode>
-    class MyEngine : public TParams::template EngineT<mode> {};
-
-    REACTIVE_DOMAIN(MyDomain, TParams::mode, MyEngine)
-};
-
-TYPED_TEST_CASE_P(TransactionTest);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Concurrent transactions test 1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Concurrent1)
-{
-    using D = typename Concurrent1::MyDomain;
-
-    std::vector<int> results;
-
-    auto n1 = MakeVar<D>(1);
-    auto n2 = n1 + 1;
-    auto n3 = n2 + n1 + 1;
-    auto n4 = n3 + 1;
-    auto n5 = n4 + n3 + n1 + 1;
-    auto n6 = n5 + 1;
-    auto n7 = n6 + n5 + 1;
-    auto n8 = n7 + 1;
-    auto n9 = n8 + n7 + n5 + n1 + 1;
-    auto n10 = n9 + 1;
-    auto n11 = n10 + n9 + 1;
-    auto n12 = n11 + 1;
-    auto n13 = n12 + n11 + n9 + 1;
-    auto n14 = n13 + 1;
-    auto n15 = n14 + n13 + 1;
-    auto n16 = n15 + 1;
-    auto n17 = n16 + n15 + n13 + n9 + 1;
-
-    Observe(n17, [&] (int v)
-    {
-        results.push_back(v);
-    });
-
-    n1 <<= 10;        // 7732
-    n1 <<= 100;        // 68572
-    n1 <<= 1000;    // 676972
-
-    ASSERT_EQ(results.size(), 3);
-
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 7732) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 68572) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 676972) != results.end());
-
-    // Reset
-    n1 <<= 1;
-    results.clear();
-
-    // Now do the same from 3 threads
-
-    std::thread t1([&]    { n1 <<= 10; });
-    std::thread t2([&]    { n1 <<= 100; });
-    std::thread t3([&]    { n1 <<= 1000; });
-
-    t1.join();
-    t2.join();
-    t3.join();
-
-    ASSERT_EQ(results.size(), 3);
-
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 7732) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 68572) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 676972) != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Concurrent transactions test 2
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Concurrent2)
-{
-    using D = typename Concurrent2::MyDomain;
-
-    std::vector<int> results;
-
-    auto in = MakeVar<D>(-1);
-
-    // 1. Generate graph
-    Signal<D,int> n0 = in;
-
-    auto next = n0;
-
-    for (int i=0; i < 100; i++)
-    {
-        auto q = next + 0;
-        next = q;
-    }
-
-    Observe(next, [&] (int v)
-    {
-        results.push_back(v);
-    });
-
-    // 2. Send events
-    std::thread t1([&]
-    {
-        for (int i=0; i<100; i++)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 50));
-            in <<= i;
-        }
-    });
-
-    std::thread t2([&]
-    {
-        for (int i=100; i<200; i++)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 50));
-            in <<= i;
-        }
-    });
-
-    std::thread t3([&]
-    {
-        for (int i=200; i<300; i++)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 50));
-            in <<= i;
-        }
-    });
-
-    t1.join();
-    t2.join();
-    t3.join();
-
-    ASSERT_EQ(results.size(), 300);
-
-    for (int i=0; i<300; i++)
-    {
-        ASSERT_TRUE(std::find(results.begin(), results.end(), i) != results.end());
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Concurrent transactions test 3
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Concurrent3)
-{
-    using D = typename Concurrent3::MyDomain;
-
-    std::vector<int> results;
-
-    std::function<int(int)> f_0 = [] (int a) -> int
-    {
-        for (int i = 0; i<(a+1)*100; i++);
-        return a + 1;
-    };
-
-    std::function<int(int,int)> f_n = [] (int a, int b) -> int
-    {
-        for (int i = 0; i<(a+b)*100; i++);
-        return a + b;
-    };
-
-    auto n1 = MakeVar<D>(1);
-    auto n2 = n1 ->* f_0;
-    auto n3 = ((n2, n1) ->* f_n) ->* f_0;
-    auto n4 = n3 ->* f_0;
-    auto n5 = ((((n4, n3) ->* f_n), n1) ->* f_n) ->* f_0;
-    auto n6 = n5 ->* f_0;
-    auto n7 = ((n6, n5) ->* f_n) ->* f_0;
-    auto n8 = n7 ->* f_0;
-    auto n9 = ((((((n8, n7) ->* f_n), n5) ->* f_n), n1) ->* f_n) ->* f_0;
-    auto n10 = n9 ->* f_0;
-    auto n11 = ((n10, n9) ->* f_n) ->* f_0;
-    auto n12 = n11 ->* f_0;
-    auto n13 = ((((n12, n11) ->* f_n), n9) ->* f_n) ->* f_0;
-    auto n14 = n13 ->* f_0;
-    auto n15 = ((n14, n13) ->* f_n) ->* f_0;
-    auto n16 = n15 ->* f_0;
-    auto n17 = ((((((n16, n15) ->* f_n), n13) ->* f_n), n9) ->* f_n)  ->* f_0;
-
-    Observe(n17, [&] (int v)
-    {
-        results.push_back(v);
-    });
-
-    n1 <<= 1000;    // 676972
-    n1 <<= 100;     // 68572
-    n1 <<= 10;      // 7732
-
-
-    ASSERT_EQ(results.size(), 3);
-
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 7732) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 68572) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 676972) != results.end());
-
-    // Reset
-    n1 <<= 1;
-    results.clear();
-    
-    std::thread t3([&]    { n1 <<= 1000; });
-    std::thread t2([&]    { n1 <<= 100; });
-    std::thread t1([&]    { n1 <<= 10; });
-    
-    t3.join();
-    t2.join();
-    t1.join();
-
-
-    ASSERT_EQ(results.size(), 3);
-
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 7732) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 68572) != results.end());
-    ASSERT_TRUE(std::find(results.begin(), results.end(), 676972) != results.end());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Merging1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Merging1)
-{
-    using D = typename Merging1::MyDomain;
-
-    std::vector<int> results;
-
-    std::atomic<bool> shouldSpin(false);
-
-    std::function<int(int)> f = [&shouldSpin] (int a) -> int
-    {
-        while (shouldSpin);
-
-        return a;
-    };
-
-    auto n1 = MakeVar<D>(1);
-    auto n2 = n1 ->* f;
-
-    Observe(n2, [&] (int v) {
-        results.push_back(v);
-    });
-
-    // Todo: improve this as it'll fail occasionally
-    shouldSpin = true;
-    std::thread t1([&] {
-        DoTransaction<D>(allow_merging, [&] {
-            n1 <<= 2;
-        });
-    });
-    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
-    std::thread t2([&] {
-        DoTransaction<D>(allow_merging, [&] {
-            n1 <<= 3;
-        });
-    });
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    std::thread t3([&] {
-        DoTransaction<D>(allow_merging, [&] {
-            n1 <<= 4;
-        });
-    });
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    std::thread t4([&] {
-        DoTransaction<D>(allow_merging, [&] {
-            n1 <<= 5;
-        });
-        
-    });
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-    shouldSpin = false;
-
-    t1.join();
-    t2.join();
-    t3.join();
-    t4.join();
-
-    ASSERT_EQ(results.size(), 2);
-    ASSERT_TRUE(results[0] == 2);
-    ASSERT_TRUE(results[1] == 5);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Async1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Async1)
-{
-    using D = typename Async1::MyDomain;
-
-    std::vector<int> results;
-
-    auto in = MakeVar<D>(1);
-    auto s1 = in * 1000;
-
-    Observe(s1, [&] (int v) {
-        results.push_back(v);
-    });
-
-    TransactionStatus st;
-
-    AsyncTransaction<D>(st, [&] {
-        in <<= 10;
-    });
-
-    AsyncTransaction<D>(st, [&] {
-        in <<= 20;
-    });
-
-    AsyncTransaction<D>(st, [&] {
-        in <<= 30;
-    });
-
-    st.Wait();
-
-    ASSERT_EQ(results.size(), 3);
-    ASSERT_TRUE(results[0] == 10000);
-    ASSERT_TRUE(results[1] == 20000);
-    ASSERT_TRUE(results[2] == 30000);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// AsyncMerging1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, AsyncMerging1)
-{
-    using D = typename AsyncMerging1::MyDomain;
-
-    std::vector<int> results;
-
-    auto in = MakeVar<D>(1);
-    auto s1 = in * 1000;
-
-    Observe(s1, [&] (int v) {
-        results.push_back(v);
-    });
-
-    TransactionStatus st;
-
-    AsyncTransaction<D>(allow_merging, st, [&] {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-        in <<= 10;
-    });
-
-    // Make sure other async transaction gets to start
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-    // These two can still be pulled in after the first input function is done
-    AsyncTransaction<D>(allow_merging, st, [&] {
-        in <<= 20;
-    });
-
-    AsyncTransaction<D>(allow_merging, st, [&] {
-        in <<= 30;
-    });
-
-    // Can't be merged
-    AsyncTransaction<D>(st, [&] {
-        in <<= 40;
-    });
-
-    // These two should be merged again
-    AsyncTransaction<D>(allow_merging, st, [&] {
-        in <<= 50;
-    });
-
-    AsyncTransaction<D>(allow_merging, st, [&] {
-        in <<= 60;
-    });
-
-    st.Wait();
-
-    ASSERT_EQ(results.size(), 3);
-    ASSERT_TRUE(results[0] == 30000);
-    ASSERT_TRUE(results[1] == 40000);
-    ASSERT_TRUE(results[2] == 60000);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Continuation1
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Continuation1)
-{
-    using D = typename Continuation1::MyDomain;
-
-    std::vector<int> results;
-
-    auto in = MakeVar<D>(0);
-
-    auto cont = MakeContinuation(in, [&] (int v) {
-        results.push_back(v);
-
-        if (v < 10)
-            in <<= v + 1;
-    });
-
-    in <<= 1;
-
-    ASSERT_EQ(results.size(), 10);
-    for (int i=0; i<10; i++)
-        ASSERT_TRUE(results[i] == i+1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Continuation2
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Continuation2)
-{
-    using L = typename Continuation2::MyDomain;
-
-    REACTIVE_DOMAIN(R, sequential_concurrent)
-
-    std::vector<int> results;
-
-    auto srcL = MakeVar<L>(0);
-    auto srcR = MakeVar<R>(0);
-
-    auto contL = MakeContinuation<L,R>(srcL, [&] (int v) {
-        results.push_back(v);
-        if (v < 10)
-            srcR <<= v+1;
-    });
-
-    auto contR = MakeContinuation<R,L>(Monitor(srcR), [&] (int v) {
-        results.push_back(v);
-        if (v < 10)
-            srcL <<= v+1;
-    });
-
-    srcL <<= 1;
-
-    ASSERT_EQ(results.size(), 10);
-    for (int i=0; i<10; i++)
-        ASSERT_TRUE(results[i] == i+1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Continuation3
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Continuation3)
-{
-    using L = typename Continuation3::MyDomain;
-
-    REACTIVE_DOMAIN(R, sequential_concurrent)
-
-    std::vector<int> results;
-
-    auto srcL = MakeVar<L>(0);
-    auto depL1 = MakeVar<L>(100);
-    auto depL2 = MakeVar<L>(10);
-    auto srcR = MakeVar<R>(0);
-
-    auto contL = MakeContinuation<L,R>(
-        Monitor(srcL),
-        With(depL1, depL2),
-        [&] (int v, int depL1, int depL2) {
-            ASSERT_EQ(depL1, v*100);
-            ASSERT_EQ(depL2, v*10);
-            results.push_back(v);
-            if (v < 10)
-                srcR <<= v+1;
-        });
-
-    auto contR = MakeContinuation<R,L>(
-        Monitor(srcR),
-        [&] (int v) {
-            results.push_back(v);
-
-            v++;
-            depL1 <<= v*100;
-            depL2 <<= v*10;
-            if (v < 10)
-                srcL <<= v;
-        });
-
-    srcL <<= 1;
-
-    ASSERT_EQ(results.size(), 10);
-    for (int i=0; i<10; i++)
-        ASSERT_TRUE(results[i] == i+1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Continuation4 test
-///////////////////////////////////////////////////////////////////////////////////////////////////
-TYPED_TEST_P(TransactionTest, Continuation4)
-{
-    using D = typename Continuation4::MyDomain;
-
-    using std::vector;
-
-    auto vect = MakeVar<D>(vector<int>{});
-
-    int count = 0;
-
-    auto cont = MakeContinuation(vect, [&] (const vector<int>& v)
-    {    
-        if (count == 0)
-        {
-            ASSERT_EQ(v[0], 30);
-
-            vect.Modify([] (vector<int>& v) {
-                v.push_back(50);
-            });
-        }
-        else if (count == 1)
-        {
-            ASSERT_EQ(v[1], 50);
-
-            vect.Modify([] (vector<int>& v) {
-                v.push_back(70);
-            });
-        }
-        else
-        {
-            ASSERT_EQ(v[2], 70);
-        }
-
-        count++;
-    });
-
-    vect.Modify([] (vector<int>& v) {
-        v.push_back(30);
-    });
-
-    ASSERT_EQ(count, 3);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-REGISTER_TYPED_TEST_CASE_P
-(
-    TransactionTest,
-    Concurrent1,
-    Concurrent2,
-    Concurrent3,
-    Merging1,
-    Async1,
-    AsyncMerging1,
-    Continuation1,
-    Continuation2,
-    Continuation3,
-    Continuation4
-);
-
-} // ~namespace
diff --git a/tests/src/algorithm_tests.cpp b/tests/src/algorithm_tests.cpp
index 6054092a..49bd221c 100644
--- a/tests/src/algorithm_tests.cpp
+++ b/tests/src/algorithm_tests.cpp
@@ -4,9 +4,713 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
+#include "gtest/gtest.h"
+
+#include "react/algorithm.h"
+#include "react/observer.h"
+
+#include <algorithm>
+#include <chrono>
+#include <queue>
+#include <string>
+#include <thread>
+#include <tuple>
+
+using namespace react;
+
+TEST(AlgorithmTest, Hold)
+{
+    // Hold last value of event source in state.
+
+    Group g;
+
+    EventSource<int> evt1( g );
+
+    State<int> st = Hold(1, evt1);
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (int v)
+        {
+            ++turns;
+            output = v;
+        }, st);
+
+    // Initial call. Output should take the value of initial value.
+    EXPECT_EQ(1, output);
+    EXPECT_EQ(1, turns);
+
+    // Event changes value.
+    evt1.Emit(10);
+    
+    EXPECT_EQ(10, output);
+    EXPECT_EQ(2, turns);
+
+    // New event, but same value, observer should not be called.
+    evt1.Emit(10);
+
+    EXPECT_EQ(10, output);
+    EXPECT_EQ(2, turns);
+}
+
+TEST(AlgorithmTest, Monitor1)
+{
+    // Emit events when value of state changes.
+
+    Group g;
+
+    StateVar<int> st( g, 1 );
+
+    Event<int> evt = Monitor( st );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& events)
+        {
+            ++turns;
+
+            for (int e : events)
+                output += e;
+        }, evt);
+
+    EXPECT_EQ(0, output);
+    EXPECT_EQ(0, turns);
+
+    // Change from 1 -> 10: Event.
+    st.Set(10);
+
+    // Change from 10 -> 20: Event.
+    st.Set(20);
+
+    // Change from 20 -> 20: No event.
+    st.Set(20);
+
+    // 10 + 20 were the changes.
+    EXPECT_EQ(30, output);
+    EXPECT_EQ(2, turns);
+}
+
+TEST(AlgorithmTest, Monitor2)
+{
+    // Monitor state changes and filter the resulting events.
+
+    Group g;
+
+    StateVar<int> target( g, 10 );
+
+    std::vector<int> results;
+
+    auto filterFunc = [] (int v) { return v > 10; };
+
+    {
+        // Observer is created in a nested scope so it gets destructed before the end of this function.
+
+        Observer obs([&] (const auto& events)
+            {
+                for (int e : events)
+                    results.push_back(e);
+            }, Filter(filterFunc, Monitor(target)));
+
+        // Change the value a couple of times.
+        target.Set(10); // Change, but <= 10
+        target.Set(20); // Change
+        target.Set(20); // No change
+        target.Set(10); // Change, but <= 10
+
+        // Only 1 non-filtered change should go through.
+        EXPECT_EQ(results.size(), 1);
+        EXPECT_EQ(results[0], 20);
+    }
+
+    target.Set(100); // Change, >100, but observer is gone.
+
+    // No changes to results without the observer.
+    ASSERT_EQ(results.size(), 1);
+}
+
+TEST(AlgorithmTest, Snapshot)
+{
+    Group g;
+
+    StateVar<int> sv( g, 1 );
+    EventSource<> es( g );
+
+    State<int> st = Snapshot( sv, es );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (int v)
+        {
+            ++turns;
+            output = v;
+        }, st);
+
+    EXPECT_EQ(1, output);
+    EXPECT_EQ(1, turns);
+
+    sv.Set(10);
+
+    EXPECT_EQ(1, output);
+    EXPECT_EQ(1, turns);
+
+    es.Emit();
+
+    EXPECT_EQ(10, output);
+    EXPECT_EQ(2, turns);
+}
+
+TEST(AlgorithmTest, Pulse)
+{
+    Group g;
+
+    StateVar<int> sv( g, 1 );
+    EventSource<> es( g );
+
+    Event<int> st = Pulse( sv, es );
+
+    int output = 0;
+    int turns = 0;
+
+    Observer obs([&] (const auto& events)
+        {
+            for (int e : events)
+            {
+                ++turns;
+                output += e;
+            }
+        }, st);
+
+    EXPECT_EQ(0, output);
+    EXPECT_EQ(0, turns);
+
+    sv.Set(10);
+
+    EXPECT_EQ(0, output);
+    EXPECT_EQ(0, turns);
+
+    es.Emit();
+
+    EXPECT_EQ(10, output);
+    EXPECT_EQ(1, turns);
+}
+
+TEST(AlgorithmTest, Iterate1)
+{
+    Group g;
+
+    EventSource<int> numSrc( g );
+
+    State<int> numFold = Iterate<int>(0, [] (const auto& events, int v)
+        {
+            for (int e : events)
+                v += e;
+            return v;
+        }, numSrc);
+
+    for (int i=1; i<=100; ++i)
+        numSrc << i;
+
+    int output = 0;
+    Observer obs([&] (int v) { output = v; }, numFold);
+
+    EXPECT_EQ(output, 5050);
+}
+
+TEST(AlgorithmTest, Iterate2)
+{
+    Group g;
+
+    EventSource<char> charSrc( g );
+
+    State<std::string> strFold = Iterate<std::string>(std::string(""), [] (const auto& events, std::string s)
+        {
+            for (char c : events)
+                s += c;
+            return s;
+        }, charSrc);
+
+    std::string output;
+    Observer obs([&] (const auto& v) { output = v; }, strFold);
+
+    charSrc << 'T' << 'e' << 's' << 't';
+
+    EXPECT_EQ(output, "Test");
+}
+
+TEST(AlgorithmTest, Iterate3)
+{
+    Group g;
+
+    EventSource<int> numSrc( g );
+
+    State<int> numFold = Iterate<int>(0, [] (const auto& events, int v)
+        {
+            for (int e : events)
+                v += e;
+            return v;
+        }, numSrc);
+
+    int turns = 0;
+    int output = 0;
+
+    Observer obs([&] (const auto& v)
+        {
+            ++turns;
+            output = v;
+        }, numFold);
+
+    g.DoTransaction([&]
+        {
+            for (int i=1; i<=100; i++)
+                numSrc << i;
+        });
+
+    EXPECT_EQ(turns, 2);
+    EXPECT_EQ(output, 5050);
+}
+
+template <typename T>
+struct Incrementer
+{
+    T operator()(const EventValueList<Token>& events, T v) const
+    { 
+        for (auto e : events)
+            ++v;
+        return v;
+    }
+};
+
+template <typename T>
+struct Decrementer
+{
+    T operator()(const EventValueList<Token>& events, T v) const
+    { 
+        for (auto e : events)
+            --v;
+        return v;
+    }
+};
+
+TEST(AlgorithmTest, Iterate4)
+{
+    Group g;
+
+    EventSource<> trigger( g );
+
+    {
+        State<int> inc = Iterate<int>(0, Incrementer<int>{ }, trigger);
+        for (int i=1; i<=100; i++)
+            trigger.Emit();
+
+        int output = 0;
+        Observer obs([&] (int v) { output = v; }, inc);
+
+        EXPECT_EQ(output, 100);
+    }
+
+    {
+        State<int> dec = Iterate<int>(200, Decrementer<int>{ }, trigger);
+        for (int i=1; i<=100; i++)
+            trigger.Emit();
+
+        int output = 0;
+        Observer obs([&] (int v) { output = v; }, dec);
+
+        ASSERT_EQ(output, 100);
+    }
+}
+
+TEST(AlgorithmTest, IterateByRef1)
+{
+    Group g;
+
+    EventSource<int> src( g );
+
+    auto x = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, auto& v)
+        {
+            for (int e : events)
+                v.push_back(e);
+        }, src);
+
+    std::vector<int> output;
+    Observer obs([&] (const auto& v) { output = v; }, x);
+
+    // Push
+    for (int i=1; i<=100; i++)
+        src << i;
+
+    EXPECT_EQ(output.size(), 100);
+
+    // Check
+    for (int i=1; i<=100; i++)
+        EXPECT_EQ(output[i-1], i);
+}
+
+TEST(AlgorithmTest, IterateByRef2)
+{
+    Group g;
+
+    EventSource<> src( g );
+
+    auto x = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, std::vector<int>& v)
+        {
+            for (Token e : events)
+                v.push_back(123);
+        }, src);
+
+    std::vector<int> output;
+    Observer obs([&] (const auto& v) { output = v; }, x);
+
+    // Push
+    for (auto i=0; i<100; i++)
+        src.Emit();
+
+    EXPECT_EQ(output.size(), 100);
+
+    // Check
+    for (auto i=0; i<100; i++)
+        EXPECT_EQ(output[i], 123);
+}
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace {
 
+template <typename T>
+T Sum(T a, T b) { return a + b; }
+
+template <typename T>
+T Prod(T a, T b) { return a * b; }
+
+template <typename T>
+T Diff(T a, T b) { return a - b; }
+
+} //~namespace
+
+TEST(AlgorithmTest, TransformWithState)
+{
+    Group g;
+
+    StateVar<int> in1( g );
+    StateVar<int> in2( g );
+
+    State<int> sum( Sum<int>, in1, in2 );
+    State<int> prod( Prod<int>, in1, in2 );
+    State<int> diff( Diff<int>, in1, in2 );
+
+    EventSource<> src1( g );
+    EventSource<int> src2( g );
+
+    auto out1 = Transform<std::tuple<int, int, int>>([] (Token, int sum, int prod, int diff)
+        {
+            return std::make_tuple(sum, prod, diff);
+        }, src1, sum, prod, diff);
+
+    auto out2 = Transform<std::tuple<int, int, int, int>>([] (int e, int sum, int prod, int diff)
+        {
+            return std::make_tuple(e, sum, prod, diff);
+        }, src2, sum, prod, diff);
+
+    int turns1 = 0;
+    int turns2 = 0;
+
+    {
+        std::tuple<int, int, int> output1;
+
+        Observer obs1([&] (const auto& events)
+            {
+                for (const auto& e : events)
+                {
+                    ++turns1;
+                    output1 = e;
+                }
+            }, out1);
+
+        std::tuple<int, int, int, int> output2;
+
+        Observer obs2([&] (const auto& events)
+            {
+                for (const auto& e : events)
+                {
+                    ++turns2;
+                    output2 = e;
+                }
+            }, out2);
+
+        in1.Set(22);
+        in2.Set(11);
+
+        src1.Emit();
+        src2.Emit(42);
+
+        EXPECT_EQ(std::get<0>(output1), 33);
+        EXPECT_EQ(std::get<1>(output1), 242);
+        EXPECT_EQ(std::get<2>(output1), 11);
+
+        EXPECT_EQ(std::get<0>(output2), 42);
+        EXPECT_EQ(std::get<1>(output2), 33);
+        EXPECT_EQ(std::get<2>(output2), 242);
+        EXPECT_EQ(std::get<3>(output2), 11);
+
+        EXPECT_EQ(turns1, 1);
+        EXPECT_EQ(turns2, 1);
+    }
+
+    {
+        std::tuple<int, int, int> output1;
+
+        Observer obs1([&] (const auto& events)
+            {
+                for (const auto& e : events)
+                {
+                    ++turns1;
+                    output1 = e;
+                }
+            }, out1);
+
+        std::tuple<int, int, int, int> output2;
+
+        Observer obs2([&] (const auto& events)
+            {
+                for (const auto& e : events)
+                {
+                    ++turns2;
+                    output2 = e;
+                }
+            }, out2);
+
+        in1.Set(220);
+        in2.Set(110);
+
+        src1.Emit();
+        src2.Emit(420);
+
+        EXPECT_EQ(std::get<0>(output1), 330);
+        EXPECT_EQ(std::get<1>(output1), 24200);
+        EXPECT_EQ(std::get<2>(output1), 110);
+
+        EXPECT_EQ(std::get<0>(output2), 420);
+        EXPECT_EQ(std::get<1>(output2), 330);
+        EXPECT_EQ(std::get<2>(output2), 24200);
+        EXPECT_EQ(std::get<3>(output2), 110);
+
+        EXPECT_EQ(turns1, 2);
+        EXPECT_EQ(turns2, 2);
+    }
+}
+
+TEST(AlgorithmTest, IterateWithState)
+{
+    Group g;
+
+    StateVar<int> in1( g );
+    StateVar<int> in2( g );
+
+    State<int> op1(Sum<int>, in1, in2);
+    State<int> op2([] (int a, int b) { return (a + b) * 10; }, in1, in2);
+
+    EventSource<> src1( g );
+    EventSource<int> src2( g );
+
+    auto out1 = Iterate<std::tuple<int, int>>(std::make_tuple(0, 0), [] (const auto& events, std::tuple<int, int> t, int op1, int op2)
+        {
+            for (const auto& e : events)
+                t = std::make_tuple(std::get<0>(t) + op1, std::get<1>(t) + op2);
+
+            return t;
+            
+        }, src1, op1, op2);
+
+    auto out2 = Iterate<std::tuple<int, int, int>>(std::make_tuple(0, 0, 0), [] (const auto& events, std::tuple<int, int, int> t, int op1, int op2)
+        {
+            for (const auto& e : events)
+                t = std::make_tuple(std::get<0>(t) + e, std::get<1>(t) + op1, std::get<2>(t) + op2);
+
+            return t;
+        }, src2, op1, op2);
+
+    int turns1 = 0;
+    int turns2 = 0;
+
+    {
+        std::tuple<int, int> output1;
+
+        Observer obs1([&] (const auto& v)
+            {
+                ++turns1;
+                output1 = v;
+            }, out1);
+
+        std::tuple<int, int, int> output2;
+
+        Observer obs2([&] (const auto& v)
+            {
+                ++turns2;
+                output2 = v;
+            }, out2);
+
+        in1.Set(22);
+        in2.Set(11);
+
+        src1.Emit();
+        src2.Emit(42);
+
+        EXPECT_EQ(std::get<0>(output1), 33);
+        EXPECT_EQ(std::get<1>(output1), 330);
+
+        EXPECT_EQ(std::get<0>(output2), 42);
+        EXPECT_EQ(std::get<1>(output2), 33);
+        EXPECT_EQ(std::get<2>(output2), 330);
+
+        EXPECT_EQ(turns1, 2);
+        EXPECT_EQ(turns2, 2);
+    }
+
+    {
+        std::tuple<int, int> output1;
+
+        Observer obs1([&] (const auto& v)
+            {
+                ++turns1;
+                output1 = v;
+            }, out1);
+
+        std::tuple<int, int, int> output2;
+
+        Observer obs2([&] (const auto& v)
+            {
+                ++turns2;
+                output2 = v;
+            }, out2);
+
+        in1.Set(220);
+        in2.Set(110);
+
+        src1.Emit();
+        src2.Emit(420);
+
+        EXPECT_EQ(std::get<0>(output1), 33 + 330);
+        EXPECT_EQ(std::get<1>(output1), 330 + 3300);
+
+        EXPECT_EQ(std::get<0>(output2), 42 + 420);
+        EXPECT_EQ(std::get<1>(output2), 33 + 330);
+        EXPECT_EQ(std::get<2>(output2), 330 + 3300);
+
+        EXPECT_EQ(turns1, 4);
+        EXPECT_EQ(turns2, 4);
+    }
+}
+
+TEST(AlgorithmTest, IterateByRefWithState)
+{
+    Group g;
+
+    StateVar<int> in1( g );
+    StateVar<int> in2( g );
+
+    State<int> op1( Sum<int>, in1, in2 );
+    State<int> op2([] (int a, int b) { return (a + b) * 10; }, in1, in2);
+
+    EventSource<> src1( g );
+    EventSource<int> src2( g );
+
+    auto out1 = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, std::vector<int>& v, int op1, int op2)
+        {
+            for (const auto& e : events)
+            {
+                v.push_back(op1);
+                v.push_back(op2);
+            }
+        }, src1, op1, op2);
+
+    auto out2 = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, std::vector<int>& v, int op1, int op2)
+        {
+            for (const auto& e : events)
+            {
+                v.push_back(e);
+                v.push_back(op1);
+                v.push_back(op2);
+            }
+        }, src2, op1, op2);
+
+    int turns1 = 0;
+    int turns2 = 0;
+
+    {
+        std::vector<int> output1;
+
+        Observer obs1([&] (const std::vector<int>& v)
+            {
+                ++turns1;
+                output1 = v;
+            }, out1);
+
+        std::vector<int> output2;
+
+        Observer obs2([&] (const std::vector<int>& v)
+            {
+                ++turns2;
+                output2 = v;
+            }, out2);
+
+        in1.Set(22);
+        in2.Set(11);
+
+        src1.Emit();
+        src2.Emit(42);
+
+        EXPECT_EQ(output1.size(), 2);
+        EXPECT_EQ(output1[0], 33);
+        EXPECT_EQ(output1[1], 330);
+
+        EXPECT_EQ(output2.size(), 3);
+        EXPECT_EQ(output2[0], 42);
+        EXPECT_EQ(output2[1], 33);
+        EXPECT_EQ(output2[2], 330);
+
+        EXPECT_EQ(turns1, 2);
+        EXPECT_EQ(turns2, 2);
+    }
+
+    {
+        std::vector<int> output1;
+
+        Observer obs1([&] (const std::vector<int>& v)
+            {
+                ++turns1;
+                output1 = v;
+            }, out1);
+
+        std::vector<int> output2;
+
+        Observer obs2([&] (const std::vector<int>& v)
+            {
+                ++turns2;
+                output2 = v;
+            }, out2);
+
+        in1.Set(220);
+        in2.Set(110);
+
+        src1.Emit();
+        src2.Emit(420);
+
+        EXPECT_EQ(output1.size(), 4);
+        EXPECT_EQ(output1[0], 33);
+        EXPECT_EQ(output1[1], 330);
+        EXPECT_EQ(output1[2], 330);
+        EXPECT_EQ(output1[3], 3300);
+
+        EXPECT_EQ(output2.size(), 6);
+        EXPECT_EQ(output2[0], 42);
+        EXPECT_EQ(output2[1], 33);
+        EXPECT_EQ(output2[2], 330);
+        EXPECT_EQ(output2[3], 420);
+        EXPECT_EQ(output2[4], 330);
+        EXPECT_EQ(output2[5], 3300);
 
-} // ~namespace
\ No newline at end of file
+        EXPECT_EQ(turns1, 4);
+        EXPECT_EQ(turns2, 4);
+    }
+}
diff --git a/tests/src/event_tests.cpp b/tests/src/event_tests.cpp
index 98d27bfc..168ac619 100644
--- a/tests/src/event_tests.cpp
+++ b/tests/src/event_tests.cpp
@@ -7,6 +7,7 @@
 #include "gtest/gtest.h"
 
 #include "react/event.h"
+#include "react/state.h"
 #include "react/observer.h"
 
 #include <algorithm>
@@ -168,10 +169,7 @@ TEST(EventTest, Transactions)
 
     g.DoTransaction([&]
         {
-            evt.Emit(1);
-            evt.Emit(1);
-            evt.Emit(1);
-            evt.Emit(1);
+            evt << 1 << 1 << 1 << 1;
         });
 
     EXPECT_EQ(4, output);
@@ -212,9 +210,9 @@ TEST(EventTest, Links)
                 output += e;
         }, slot);
 
-    evt1.Emit(1);
-    evt2.Emit(1);
-    evt3.Emit(1);
+    evt1 << 1;
+    evt2 << 1;
+    evt3 << 1;
 
     std::this_thread::sleep_for(std::chrono::seconds(1));
 
@@ -244,13 +242,8 @@ TEST(EventTest, EventSources)
                 results2.push(e);
         }, es2);
 
-    es1.Emit(10);
-    es1.Emit(20);
-    es1.Emit(30);
-
-    es2.Emit(40);
-    es2.Emit(50);
-    es2.Emit(60);
+    es1 << 10 << 20 << 30;
+    es2 << 40 << 50 << 60;
 
     // First batch.
     EXPECT_FALSE(results1.empty());
@@ -453,7 +446,7 @@ TEST(EventTest, Transform)
     EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD") != results.end());
 }
 
-TEST(EventTest, Chain)
+TEST(EventTest, Flow)
 {
     Group g;
 
@@ -537,4 +530,130 @@ TEST(EventTest, Join)
     in1.Emit(20);
     EXPECT_EQ(results.size(), 2);
     EXPECT_EQ(results[1], std::make_tuple(20, 20, 20));
+}
+
+TEST(EventTest, FilterWithState)
+{
+    Group g;
+
+    EventSource<std::string> in( g );
+
+    StateVar<int> sig1( g, 1338 );
+    StateVar<int> sig2( g, 1336 );
+
+    EventSource<int> in2( g );
+
+    auto filtered = Filter([] (const std::string& s, int sig1, int sig2)
+        {
+            return s == "Hello World" && sig1 > sig2;
+        }, in, sig1, sig2);
+
+    std::queue<std::string> results;
+
+    Observer obs([&] (const auto& events)
+        {
+            for (const auto& e : events)
+                results.push(e);
+        }, filtered);
+
+    in << std::string("Hello Worlt") << std::string("Hello World") << std::string("Hello Vorld");
+    sig1.Set(1335);
+    in << std::string("Hello Vorld");
+
+    EXPECT_FALSE(results.empty());
+    EXPECT_EQ(results.front(), "Hello World");
+    results.pop();
+
+    EXPECT_TRUE(results.empty());
+}
+
+TEST(EventTest, TransformWithState)
+{
+    Group g;
+
+    std::vector<std::string> results;
+
+    EventSource<std::string> in1( g );
+    EventSource<std::string> in2( g );
+
+    Event<std::string> merged = Merge(in1, in2);
+
+    StateVar<std::string> first( g, "Ace" );
+    StateVar<std::string> last( g, "McSteele" );
+
+    auto transformed = Transform<std::string>([] (std::string s, const std::string& first, const std::string& last) -> std::string
+        {
+            std::transform(s.begin(), s.end(), s.begin(), ::toupper);
+            s += std::string(", ") + first + std::string(" ") + last;
+            return s;
+        }, merged, first, last);
+
+    Observer obs([&] (const auto& events)
+        {
+            for (const auto& e : events)
+                results.push_back(e);
+        }, transformed);
+
+    in1 << std::string("Hello Worlt") << std::string("Hello World");
+
+    g.DoTransaction([&]
+        {
+            in2 << std::string("Hello Vorld");
+            first.Set(std::string("Alice"));
+            last.Set(std::string("Anderson"));
+        });
+
+    EXPECT_EQ(results.size(), 3);
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLT, Ace McSteele") != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO WORLD, Ace McSteele") != results.end());
+    EXPECT_TRUE(std::find(results.begin(), results.end(), "HELLO VORLD, Alice Anderson") != results.end());
+}
+
+TEST(EventTest, FlowWithState)
+{
+    Group g;
+
+    std::vector<float> results;
+
+    EventSource<int> in1( g );
+    EventSource<int> in2( g );
+
+    StateVar<int> mult( g, 10 );
+
+    Event<int> merged = Merge(in1, in2);
+    int callCount = 0;
+
+    Event<float> processed([&] (const auto& events, auto out, int mult)
+        {
+            for (const auto& e : events)
+            {
+                *out = 0.1f * e * mult;
+                *out = 1.5f * e * mult;
+            }
+
+            callCount++;
+        }, merged, mult);
+
+    Observer obs([&] (const auto& events)
+        {
+            for (float e : events)
+                results.push_back(e);
+        }, processed);
+
+    g.DoTransaction([&]
+        {
+            in1 << 10 << 20;
+        });
+
+    in2 << 30;
+
+    EXPECT_EQ(results.size(), 6);
+    EXPECT_EQ(callCount, 2);
+
+    EXPECT_EQ(results[0], 10.0f);
+    EXPECT_EQ(results[1], 150.0f);
+    EXPECT_EQ(results[2], 20.0f);
+    EXPECT_EQ(results[3], 300.0f);
+    EXPECT_EQ(results[4], 30.0f);
+    EXPECT_EQ(results[5], 450.0f);
 }
\ No newline at end of file
diff --git a/tests/src/state_tests.cpp b/tests/src/state_tests.cpp
index 7cca28db..953cedc8 100644
--- a/tests/src/state_tests.cpp
+++ b/tests/src/state_tests.cpp
@@ -202,6 +202,9 @@ TEST(StateTest, Links)
     std::this_thread::sleep_for(std::chrono::seconds(1));
 }
 
+namespace
+{
+
 template <typename T>
 static T Sum2(T a, T b)
 {
@@ -214,7 +217,9 @@ static T Sum3(T a, T b, T c)
     return a + b + c;
 }
 
-TEST(StateTest, StateCombination)
+} // ~namespace
+
+TEST(StateTest, StateCombination1)
 {
     Group g;
 
@@ -259,4 +264,164 @@ TEST(StateTest, StateCombination)
 
     EXPECT_EQ(3, output2);
     EXPECT_EQ(4, turns2);
+}
+
+TEST(StateTest, StateCombination2)
+{
+    Group g;
+
+    std::vector<int> results;
+
+    StateVar<int> n1( g, 1 );
+
+    State<int> n2([] (int n1)
+        { return n1 + 1; }, n1);
+
+    State<int> n3([] (int n1, int n2)
+        { return n2 + n1 + 1; }, n1, n2);
+
+    State<int> n4([] (int n3)
+        { return n3 + 1; }, n3);
+
+    State<int> n5([] (int n1, int n3, int n4)
+        { return n4 + n3 + n1 + 1; }, n1, n3, n4);
+
+    State<int> n6([] (int n5)
+        { return n5 + 1; }, n5);
+
+    State<int> n7([] (int n5, int n6)
+        { return n6 + n5 + 1; }, n5, n6);
+
+    State<int> n8([] (int n7)
+        { return n7 + 1; }, n7);
+
+    State<int> n9([] (int n1, int n5, int n7, int n8)
+        { return n8 + n7 + n5 + n1 + 1; }, n1, n5, n7, n8);
+
+    State<int> n10([] (int n9)
+        { return n9 + 1; }, n9);
+
+    State<int> n11([] (int n9, int n10)
+        { return n10 + n9 + 1; }, n9, n10);
+
+    State<int> n12([] (int n11)
+        { return n11 + 1; }, n11);
+
+    State<int> n13([] (int n9, int n11, int n12)
+        { return n12 + n11 + n9 + 1; }, n9, n11, n12);
+
+    State<int> n14([] (int n13)
+        { return n13 + 1; }, n13);
+
+    State<int> n15([] (int n13, int n14)
+        { return n14 + n13 + 1; }, n13, n14);
+
+    State<int> n16([] (int n15)
+        { return n15 + 1; }, n15);
+
+    State<int> n17([] (int n9, int n13, int n15, int n16)
+        { return n16 + n15 + n13 + n9 + 1; }, n9, n13, n15, n16);
+
+    Observer obs([&] (int v) { results.push_back(v); }, n17);
+
+    n1.Set(10);     // 7732
+    n1.Set(100);    // 68572
+    n1.Set(1000);   // 676972
+
+    EXPECT_EQ(results.size(), 4);
+
+    EXPECT_EQ(results[0], 1648);
+    EXPECT_EQ(results[1], 7732);
+    EXPECT_EQ(results[2], 68572);
+    EXPECT_EQ(results[3], 676972);
+}
+
+TEST(StateTest, Modify1)
+{
+    Group g;
+
+    std::vector<int> results;
+
+    StateVar<std::vector<int>> var( g, std::vector<int>{ } );
+
+    int turns = 0;
+
+    Observer obs([&] (const std::vector<int>& v)
+        {
+            ++turns;
+            results = v;
+        }, var);
+    
+    var.Modify([] (std::vector<int>& v)
+        {
+            v.push_back(30);
+            v.push_back(50);
+            v.push_back(70);
+        });
+
+    EXPECT_EQ(results[0], 30);
+    EXPECT_EQ(results[1], 50);
+    EXPECT_EQ(results[2], 70);
+
+    EXPECT_EQ(turns, 2);
+}
+
+TEST(StateTest, Modify2)
+{
+    Group g;
+
+    std::vector<int> results;
+
+    StateVar<std::vector<int>> var( g, std::vector<int>{ } );
+
+    int turns = 0;
+
+    Observer obs([&] (const std::vector<int>& v)
+        {
+            ++turns;
+            results = v;
+        }, var);
+    
+    g.DoTransaction([&]
+        {
+            var.Modify([] (std::vector<int>& v) { v.push_back(30); });
+            var.Modify([] (std::vector<int>& v) { v.push_back(50); });
+            var.Modify([] (std::vector<int>& v) { v.push_back(70); });
+        });
+
+    EXPECT_EQ(results[0], 30);
+    EXPECT_EQ(results[1], 50);
+    EXPECT_EQ(results[2], 70);
+
+    EXPECT_EQ(turns, 2);
+}
+
+TEST(StateTest, Modify3)
+{
+    Group g;
+
+    std::vector<int> results;
+
+    StateVar<std::vector<int>> var( g, std::vector<int>{ } );
+
+    int turns = 0;
+
+    Observer obs([&] (const std::vector<int>& v)
+        {
+            ++turns;
+            results = v;
+        }, var);
+    
+    // Also terrible
+    g.DoTransaction([&]
+        {
+            var.Set(std::vector<int>{ 30, 50 });
+            var.Modify([] (std::vector<int>& v) { v.push_back(70); });
+        });
+
+    EXPECT_EQ(results[0], 30);
+    EXPECT_EQ(results[1], 50);
+    EXPECT_EQ(results[2], 70);
+
+    ASSERT_EQ(turns, 2);
 }
\ No newline at end of file
diff --git a/tests/src/transaction_tests.cpp b/tests/src/transaction_tests.cpp
index 33812c75..01e65ac9 100644
--- a/tests/src/transaction_tests.cpp
+++ b/tests/src/transaction_tests.cpp
@@ -6,6 +6,7 @@
 
 #include "gtest/gtest.h"
 
+#include "react/state.h"
 #include "react/event.h"
 #include "react/observer.h"
 
@@ -14,7 +15,7 @@
 
 using namespace react;
 
-TEST(TransactionTests, Merging)
+TEST(TransactionTest, Merging)
 {
     Group g;
 
@@ -68,7 +69,7 @@ TEST(TransactionTests, Merging)
     EXPECT_EQ(21, output);
 }
 
-TEST(TransactionTests, LinkedSync)
+TEST(TransactionTest, LinkedSync)
 {
     // Three groups. Each has one event with an observer attached.
     // The last observer adds a little delay.
@@ -138,7 +139,7 @@ TEST(TransactionTests, LinkedSync)
     EXPECT_EQ(3, output3);
 }
 
-TEST(TransactionTests, LinkedSyncMerging)
+TEST(TransactionTest, LinkedSyncMerging)
 {
     // Two groups. Each has one event with an observer attached.
     // The last observer adds a little delay.

From 6eb759c7e12e9647c9f41e35b35f665cc518f8a9 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 02:07:57 +0100
Subject: [PATCH 58/75] Refactoring of object creation: -Ctor +static Create.
 Cleanup. Object state.

---
 CMakeLists.txt                     |   6 +-
 benchmarks/src/Main.cpp            |  10 +-
 include/react/api.h                |  23 ++++
 include/react/common/syncpoint.h   |   3 +-
 include/react/detail/event_nodes.h |   7 +-
 include/react/detail/state_nodes.h |  92 ++++++++++++--
 include/react/event.h              | 149 +++++++++++-----------
 include/react/observer.h           |  55 ++++-----
 include/react/state.h              | 192 ++++++++++++++++++++---------
 project/msvc/CppReact.vcxproj      |   1 +
 tests/CMakeLists.txt               |  16 +--
 tests/src/algorithm_tests.cpp      | 112 ++++++++---------
 tests/src/event_tests.cpp          | 122 +++++++++---------
 tests/src/state_tests.cpp          | 159 ++++++++++++++++--------
 tests/src/transaction_tests.cpp    |  18 +--
 15 files changed, 594 insertions(+), 371 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ae21be06..3b6477a8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,11 +13,7 @@ include_directories ("${PROJECT_SOURCE_DIR}/include")
 
 ### CppReact
 add_library(CppReact 
-	src/engine/PulsecountEngine.cpp
-	src/engine/SubtreeEngine.cpp
-	src/engine/ToposortEngine.cpp
-	src/logging/EventLog.cpp
-	src/logging/EventRecords.cpp)
+	src/detail/graph_impl.cpp)
 
 target_link_libraries(CppReact tbb)
 
diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index bc42b726..a191ccbc 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -222,10 +222,18 @@ int main()
 
 }
 
+struct Data
+{
+    State<int> a;
+    State<int> b;
+
+    State<Data*> (a, b);
+};
+
 #endif
 
 #include "react/common/expected.h"
-#include "react/signal.h"
+#include "react/state.h"
 #include "react/event.h"
 #include "react/algorithm.h"
 #include <iostream>
diff --git a/include/react/api.h b/include/react/api.h
index d8d15204..95ce57f6 100644
--- a/include/react/api.h
+++ b/include/react/api.h
@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include <vector>
+
 #include "react/detail/defs.h"
 #include "react/common/utility.h"
 
@@ -35,6 +37,14 @@ REACT_DEFINE_BITMASK_OPERATORS(TransactionFlags)
 
 enum class Token { value };
 
+enum class InPlaceTag
+{
+    value = 1
+};
+
+static constexpr InPlaceTag in_place = InPlaceTag::value;
+
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// API types
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -55,6 +65,13 @@ class StateSlot;
 template <typename S>
 class StateLink;
 
+// Object state
+template <typename S>
+class ObjectContext;
+
+template <typename T>
+class ObjectState;
+
 // Event
 enum class Token;
 
@@ -67,6 +84,12 @@ class EventSource;
 template <typename E>
 class EventSlot;
 
+template <typename E = Token>
+using EventValueList = std::vector<E>;
+
+template <typename E>
+using EventValueSink = std::back_insert_iterator<std::vector<E>>;
+
 // Observer
 class Observer;
 
diff --git a/include/react/common/syncpoint.h b/include/react/common/syncpoint.h
index b4fc73f8..1d47952a 100644
--- a/include/react/common/syncpoint.h
+++ b/include/react/common/syncpoint.h
@@ -16,6 +16,7 @@
 #include <condition_variable>
 #include <iterator>
 #include <mutex>
+#include <vector>
 
 
 /*****************************************/ REACT_BEGIN /*****************************************/
@@ -29,8 +30,6 @@ class SyncPoint
     class Dependency;
 
 private:
-    
-
     class ISyncTarget
     {
     public:
diff --git a/include/react/detail/event_nodes.h b/include/react/detail/event_nodes.h
index 7c988b23..c918afec 100644
--- a/include/react/detail/event_nodes.h
+++ b/include/react/detail/event_nodes.h
@@ -27,11 +27,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Iterators for event processing
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename E = Token>
-using EventValueList = std::vector<E>;
-
-template <typename E>
-using EventValueSink = std::back_insert_iterator<std::vector<E>>;
 
 /******************************************/ REACT_END /******************************************/
 
@@ -493,6 +488,8 @@ template <typename E>
 class EventInternals
 {
 public:
+    EventInternals() = default;
+
     EventInternals(const EventInternals&) = default;
     EventInternals& operator=(const EventInternals&) = default;
 
diff --git a/include/react/detail/state_nodes.h b/include/react/detail/state_nodes.h
index c3b717b2..ea78c20b 100644
--- a/include/react/detail/state_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -20,12 +20,6 @@
 
 /***************************************/ REACT_IMPL_BEGIN /**************************************/
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Forward declarations
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename L, typename R>
-bool Equals(const L& lhs, const R& rhs);
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// StateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -33,12 +27,6 @@ template <typename S>
 class StateNode : public NodeBase
 {
 public:
-    StateNode(StateNode&&) = default;
-    StateNode& operator=(StateNode&&) = default;
-
-    StateNode(const StateNode&) = delete;
-    StateNode& operator=(const StateNode&) = delete;
-
     explicit StateNode(const Group& group) :
         StateNode::NodeBase( group ),
         value_( )
@@ -50,6 +38,12 @@ class StateNode : public NodeBase
         value_( std::forward<T>(value) )
     { }
 
+    template <typename ... Ts>
+    StateNode(InPlaceTag, const Group& group, Ts&& ... args) :
+        StateNode::NodeBase( group ),
+        value_( std::forward<Ts>(args) ... )
+    { }
+
     S& Value()
         { return value_; }
 
@@ -153,7 +147,7 @@ class StateVarNode : public StateNode<S>
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// StateOpNode
+/// StateFuncNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename F, typename ... TDeps>
 class StateFuncNode : public StateNode<S>
@@ -344,6 +338,64 @@ class StateLinkNode : public StateNode<S>
     VirtualOutputNode linkOutput_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// ObjectStateNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class ObjectStateNode : public StateNode<ObjectContext<S>>
+{
+public:
+    ObjectStateNode(const Group& group, S&& obj, const std::initializer_list<NodeId>& memberIds) :
+        ObjectStateNode::StateNode( group, std::move(obj) )
+    {
+        this->RegisterMe();
+
+        if (memberIds.size() == 0)
+        {
+            apply([this] (const auto& ... members)
+                {
+                    REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId()));
+                    REACT_EXPAND_PACK(this->AttachToMe(GetInternals(members).GetNodeId()));
+                }, this->Value().GetObject().GetReactiveMembers());
+        }
+        else
+        {
+            memberIds_.reserve(memberIds.size());
+
+            for (NodeId id : memberIds)
+            {
+                memberIds_.push_back(id);
+                this->AttachToMe(id);
+            }
+        }
+    }
+
+    template <typename ... Us>
+    ObjectStateNode(InPlaceTag, const Group& group, Us&& ... args) :
+        ObjectStateNode::StateNode( in_place, group, group, std::forward<Us>(args) ... )
+    {
+        this->RegisterMe();
+
+        apply([this] (const auto& ... members)
+            { REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId())); }, this->Value().GetObject().GetReactiveMembers());
+    }
+
+    ~ObjectStateNode()
+    {
+        for (NodeId id : memberIds_)
+            this->DetachFromMe(id);
+
+        this->UnregisterMe();
+    }
+
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+    {
+        return UpdateResult::changed;
+    }
+
+private:
+    std::vector<NodeId> memberIds_;
+};
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// StateInternals
@@ -352,6 +404,8 @@ template <typename S>
 class StateInternals
 {
 public:
+    StateInternals() = default;
+
     StateInternals(const StateInternals&) = default;
     StateInternals& operator=(const StateInternals&) = default;
 
@@ -381,6 +435,18 @@ class StateInternals
     std::shared_ptr<StateNode<S>> nodePtr_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// SameGroupOrLink
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+static State<S> SameGroupOrLink(const Group& targetGroup, const State<S>& dep)
+{
+    if (dep.GetGroup() == targetGroup)
+        return dep;
+    else
+        return StateLink<S>::Create(targetGroup, dep);
+}
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/event.h b/include/react/event.h
index ecde17b2..aeaaa6f6 100644
--- a/include/react/event.h
+++ b/include/react/event.h
@@ -31,35 +31,33 @@ template <typename E>
 class Event : protected REACT_IMPL::EventInternals<E>
 {
 public:
-    Event(const Event&) = default;
-    Event& operator=(const Event&) = default;
-
-    Event(Event&&) = default;
-    Event& operator=(Event&&) = default;
-
     // Construct with explicit group
     template <typename F, typename T>
-    Event(const Group& group, F&& func, const Event<T>& dep) :
-        Event::Event( CreateProcessingNode(group, std::forward<F>(func), dep) )
-    { }
+    static Event Create(const Group& group, F&& func, const Event<T>& dep)
+        { return CreateProcessingNode(group, std::forward<F>(func), dep); }
 
     // Construct with implicit group
     template <typename F, typename T>
-    Event(F&& func, const Event<T>& dep) :
-        Event::Event( CreateProcessingNode(dep.GetGroup(), std::forward<F>(func), dep) )
-    { }
+    static Event Create(F&& func, const Event<T>& dep)
+        { return CreateProcessingNode(dep.GetGroup(), std::forward<F>(func), dep); }
 
     // Construct with explicit group
     template <typename F, typename T, typename ... Us>
-    Event(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... states) :
-        Event::Event( CreateSyncedProcessingNode(group, std::forward<F>(func), dep, states ...) )
-    { }
+    static Event Create(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... states)
+        { return CreateSyncedProcessingNode(group, std::forward<F>(func), dep, states ...); }
 
     // Construct with implicit group
     template <typename F, typename T, typename ... Us>
-    Event(F&& func, const Event<T>& dep, const State<Us>& ... states) :
-        Event::Event( CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, states ...) )
-    { }
+    static Event Create(F&& func, const Event<T>& dep, const State<Us>& ... states)
+        { return CreateSyncedProcessingNode(dep.GetGroup(), std::forward<F>(func), dep, states ...); }
+
+    Event() = default;
+
+    Event(const Event&) = default;
+    Event& operator=(const Event&) = default;
+
+    Event(Event&&) = default;
+    Event& operator=(Event&&) = default;
 
     auto Tokenize() const -> decltype(auto)
         { return REACT::Tokenize(*this); }
@@ -83,13 +81,12 @@ class Event : protected REACT_IMPL::EventInternals<E>
         { return e; }
 
 protected:
-    // Private node ctor
-    explicit Event(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
+    Event(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
         Event::EventInternals( std::move(nodePtr) )
     { }
 
     template <typename F, typename T>
-    auto CreateProcessingNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
+    static auto CreateProcessingNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::EventProcessingNode;
         using REACT_IMPL::SameGroupOrLink;
@@ -99,7 +96,7 @@ class Event : protected REACT_IMPL::EventInternals<E>
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedProcessingNode(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... syncs) -> decltype(auto)
+    static auto CreateSyncedProcessingNode(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::SyncedEventProcessingNode;
         using REACT_IMPL::SameGroupOrLink;
@@ -119,16 +116,17 @@ template <typename E>
 class EventSource : public Event<E>
 {
 public:
+    // Construct event source
+    static EventSource Create(const Group& group)
+        { return CreateSourceNode(group); }
+
+    EventSource() = default;
+
     EventSource(const EventSource&) = default;
     EventSource& operator=(const EventSource&) = default;
 
     EventSource(EventSource&& other) = default;
     EventSource& operator=(EventSource&& other) = default;
-
-    // Construct event source
-    explicit EventSource(const Group& group) :
-        EventSource::Event( CreateSourceNode(group) )
-    { }
     
     void Emit(const E& value)
         { EmitValue(value); }
@@ -147,13 +145,17 @@ class EventSource : public Event<E>
         { EmitValue(std::move(value)); return *this; }
 
 protected:
-    auto CreateSourceNode(const Group& group) -> decltype(auto)
+    EventSource(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
+        EventSource::Event( std::move(nodePtr) )
+    { }
+
+private:
+    static auto CreateSourceNode(const Group& group) -> decltype(auto)
     {
         using REACT_IMPL::EventSourceNode;
         return std::make_shared<EventSourceNode<E>>(group);
     }
 
-private:
     template <typename T>
     void EmitValue(T&& value)
     {
@@ -177,17 +179,18 @@ template <typename E>
 class EventSlot : public Event<E>
 {
 public:
+    // Construct emtpy slot
+    static EventSlot Create(const Group& group)
+        { return CreateSlotNode(group); }
+
+    EventSlot() = default;
+
     EventSlot(const EventSlot&) = default;
     EventSlot& operator=(const EventSlot&) = default;
 
     EventSlot(EventSlot&&) = default;
     EventSlot& operator=(EventSlot&&) = default;
 
-    // Construct emtpy slot
-    EventSlot(const Group& group) :
-        EventSlot::Event( CreateSlotNode(group) )
-    { }
-
     void Add(const Event<E>& input)
         { AddInput(input); }
 
@@ -198,13 +201,17 @@ class EventSlot : public Event<E>
         { RemoveAllInputs(); }
 
 protected:
-    auto CreateSlotNode(const Group& group) -> decltype(auto)
+    EventSlot(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
+        EventSlot::Event( std::move(nodePtr) )
+    { }
+
+private:
+    static auto CreateSlotNode(const Group& group) -> decltype(auto)
     {
         using REACT_IMPL::EventSlotNode;
         return std::make_shared<EventSlotNode<E>>(group);
     }
 
-private:
     void AddInput(const Event<E>& input)
     {
         using REACT_IMPL::NodeId;
@@ -252,18 +259,24 @@ template <typename E>
 class EventLink : public Event<E>
 {
 public:
+    // Construct with group
+    static EventLink Create(const Group& group, const Event<E>& input)
+        { return GetOrCreateLinkNode(group, input); }
+
+    EventLink() = default;
+
     EventLink(const EventLink&) = default;
     EventLink& operator=(const EventLink&) = default;
 
     EventLink(EventLink&&) = default;
     EventLink& operator=(EventLink&&) = default;
 
-    // Construct with group
-    EventLink(const Group& group, const Event<E>& input) :
-        EventLink::Event( GetOrCreateLinkNode(group, input) )
+protected:
+    EventLink(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
+        EventLink::Event( std::move(nodePtr) )
     { }
 
-protected:
+private:
     static auto GetOrCreateLinkNode(const Group& group, const Event<E>& input) -> decltype(auto)
     {
         using REACT_IMPL::EventLinkNode;
@@ -274,9 +287,7 @@ class EventLink : public Event<E>
 
         ReactGraph::LinkCache& linkCache = GetInternals(group).GetGraphPtr()->GetLinkCache();
 
-        std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(
-            k,
-            [&]
+        std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(k, [&]
             {
                 auto nodePtr = std::make_shared<EventLinkNode<E>>(group, input);
                 nodePtr->SetWeakSelfPtr(std::weak_ptr<EventLinkNode<E>>{ nodePtr });
@@ -291,7 +302,7 @@ class EventLink : public Event<E>
 /// Merge
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E, typename ... Us>
-auto Merge(const Group& group, const Event<E>& dep1, const Event<Us>& ... deps) -> Event<E>
+static auto Merge(const Group& group, const Event<E>& dep1, const Event<Us>& ... deps) -> Event<E>
 {
     using REACT_IMPL::EventMergeNode;
     using REACT_IMPL::SameGroupOrLink;
@@ -302,79 +313,79 @@ auto Merge(const Group& group, const Event<E>& dep1, const Event<Us>& ... deps)
 }
 
 template <typename T = void, typename U1, typename ... Us>
-auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
+static auto Merge(const Event<U1>& dep1, const Event<Us>& ... deps) -> decltype(auto)
     { return Merge(dep1.GetGroup(), dep1, deps ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Filter
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename F, typename E>
-auto Filter(const Group& group, F&& pred, const Event<E>& dep) -> Event<E>
+static auto Filter(const Group& group, F&& pred, const Event<E>& dep) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& events, EventValueSink<E> out)
         { std::copy_if(events.begin(), events.end(), out, capturedPred); };
 
-    return Event<E>(group, std::move(filterFunc), dep);
+    return Event<E>::Create(group, std::move(filterFunc), dep);
 }
 
 template <typename F, typename E>
-auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
+static auto Filter(F&& pred, const Event<E>& dep) -> Event<E>
     { return Filter(dep.GetGroup(), std::forward<F>(pred), dep); }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(const Group& group, F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
+static auto Filter(const Group& group, F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
 {
     auto filterFunc = [capturedPred = std::forward<F>(pred)] (const EventValueList<E>& evts, EventValueSink<E> out, const Ts& ... values)
-    {
-        for (const auto& v : evts)
-            if (capturedPred(v, values ...))
-                *out++ = v;
-    };
+        {
+            for (const auto& v : evts)
+                if (capturedPred(v, values ...))
+                    *out++ = v;
+        };
 
-    return Event<E>(group, std::move(filterFunc), dep, states ...);
+    return Event<E>::Create(group, std::move(filterFunc), dep, states ...);
 }
 
 template <typename F, typename E, typename ... Ts>
-auto Filter(F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
+static auto Filter(F&& pred, const Event<E>& dep, const State<Ts>& ... states) -> Event<E>
     { return Filter(dep.GetGroup(), std::forward<F>(pred), dep, states ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Transform
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename E, typename F, typename T>
-auto Transform(const Group& group, F&& op, const Event<T>& dep) -> Event<E>
+static auto Transform(const Group& group, F&& op, const Event<T>& dep) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(op)] (const EventValueList<T>& evts, EventValueSink<E> out)
         { std::transform(evts.begin(), evts.end(), out, capturedOp); };
 
-    return Event<E>(group, std::move(transformFunc), dep);
+    return Event<E>::Create(group, std::move(transformFunc), dep);
 }
 
 template <typename E, typename F, typename T>
-auto Transform(F&& op, const Event<T>& dep) -> Event<E>
+static auto Transform(F&& op, const Event<T>& dep) -> Event<E>
     { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep); }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(const Group& group, F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
+static auto Transform(const Group& group, F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
 {
     auto transformFunc = [capturedOp = std::forward<F>(op)] (const EventValueList<T>& evts, EventValueSink<E> out, const Us& ... values)
-    {
-        for (const auto& v : evts)
-            *out++ = capturedOp(v, values ...);
-    };
+        {
+            for (const auto& v : evts)
+                *out++ = capturedOp(v, values ...);
+        };
 
-    return Event<E>(group, std::move(transformFunc), dep, states ...);
+    return Event<E>::Create(group, std::move(transformFunc), dep, states ...);
 }
 
 template <typename E, typename F, typename T, typename ... Us>
-auto Transform(F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
+static auto Transform(F&& op, const Event<T>& dep, const State<Us>& ... states) -> Event<E>
     { return Transform<E>(dep.GetGroup(), std::forward<F>(op), dep, states ...); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Join
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename U1, typename ... Us>
-auto Join(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
+static auto Join(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
 {
     using REACT_IMPL::EventJoinNode;
     using REACT_IMPL::SameGroupOrLink;
@@ -387,7 +398,7 @@ auto Join(const Group& group, const Event<U1>& dep1, const Event<Us>& ... deps)
 }
 
 template <typename U1, typename ... Us>
-auto Join(const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
+static auto Join(const Event<U1>& dep1, const Event<Us>& ... deps) -> Event<std::tuple<U1, Us ...>>
     { return Join(dep1.GetGroup(), dep1, deps ...); }
 
 /******************************************/ REACT_END /******************************************/
@@ -400,7 +411,7 @@ static Event<E> SameGroupOrLink(const Group& targetGroup, const Event<E>& dep)
     if (dep.GetGroup() == targetGroup)
         return dep;
     else
-        return EventLink<E>{ targetGroup, dep };
+        return EventLink<E>::Create(targetGroup, dep);
 }
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/observer.h b/include/react/observer.h
index 3f228ffd..a5360478 100644
--- a/include/react/observer.h
+++ b/include/react/observer.h
@@ -29,57 +29,50 @@ class Observer : protected REACT_IMPL::ObserverInternals
     using NodeType = REACT_IMPL::ObserverNode;
 
 public:
-    Observer(const Observer&) = default;
-    Observer& operator=(const Observer&) = default;
-
-    Observer(Observer&&) = default;
-    Observer& operator=(Observer&&) = default;
-
     // Construct state observer with explicit group
     template <typename F, typename T1, typename ... Ts>
-    Observer(const Group& group, F&& func, const State<T1>& subject1, const State<Ts>& ... subjects) :
-        Observer::Observer( CreateStateObserverNode(group, std::forward<F>(func), subject1, subjects ...))
-    { }
+    static Observer Create(const Group& group, F&& func, const State<T1>& subject1, const State<Ts>& ... subjects)
+        { return CreateStateObserverNode(group, std::forward<F>(func), subject1, subjects ...); }
 
     // Construct state observer with implicit group
     template <typename F, typename T1, typename ... Ts>
-    Observer(F&& func, const State<T1>& subject1, const State<Ts>& ... subjects) :
-        Observer::Observer( CreateStateObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...))
-    { }
+    static Observer Create(F&& func, const State<T1>& subject1, const State<Ts>& ... subjects)
+        { return CreateStateObserverNode(subject1.GetGroup(), std::forward<F>(func), subject1, subjects ...); }
 
     // Construct event observer with explicit group
     template <typename F, typename T>
-    Observer(const Group& group, F&& func, const Event<T>& subject) :
-        Observer::Observer( CreateEventObserverNode(group, std::forward<F>(func), subject))
-    { }
+    static Observer Create(const Group& group, F&& func, const Event<T>& subject)
+        { return  CreateEventObserverNode(group, std::forward<F>(func), subject); }
 
     // Construct event observer with implicit group
     template <typename F, typename T>
-    Observer(F&& func, const Event<T>& subject) :
-        Observer::Observer( CreateEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject))
-    { }
+    static Observer Create(F&& func, const Event<T>& subject)
+        { return CreateEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject); }
 
     // Constructed synced event observer with explicit group
     template <typename F, typename T, typename ... Us>
-    Observer(const Group& group, F&& func, const Event<T>& subject, const State<Us>& ... states) :
-        Observer::Observer( CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, states ...))
-    { }
+    static Observer Create(const Group& group, F&& func, const Event<T>& subject, const State<Us>& ... states)
+        { return CreateSyncedEventObserverNode(group, std::forward<F>(func), subject, states ...); }
 
     // Constructed synced event observer with implicit group
     template <typename F, typename T, typename ... Us>
-    Observer(F&& func, const Event<T>& subject, const State<Us>& ... states) :
-        Observer::Observer( CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, states ...))
-    { }
+    static Observer Create(F&& func, const Event<T>& subject, const State<Us>& ... states)
+        { return CreateSyncedEventObserverNode(subject.GetGroup(), std::forward<F>(func), subject, states ...); }
+
+    Observer(const Observer&) = default;
+    Observer& operator=(const Observer&) = default;
 
-public: //Internal
-    // Private node ctor
-    explicit Observer(std::shared_ptr<NodeType>&& nodePtr) :
+    Observer(Observer&&) = default;
+    Observer& operator=(Observer&&) = default;
+
+protected: //Internal
+    Observer(std::shared_ptr<NodeType>&& nodePtr) :
         nodePtr_(std::move(nodePtr))
     { }
 
-protected:
+private:
     template <typename F, typename T1, typename ... Ts>
-    auto CreateStateObserverNode(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) -> decltype(auto)
+    static auto CreateStateObserverNode(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::StateObserverNode;
         return std::make_shared<StateObserverNode<typename std::decay<F>::type, T1, Ts ...>>(
@@ -87,7 +80,7 @@ class Observer : protected REACT_IMPL::ObserverInternals
     }
 
     template <typename F, typename T>
-    auto CreateEventObserverNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
+    static auto CreateEventObserverNode(const Group& group, F&& func, const Event<T>& dep) -> decltype(auto)
     {
         using REACT_IMPL::EventObserverNode;
         return std::make_shared<EventObserverNode<typename std::decay<F>::type, T>>(
@@ -95,7 +88,7 @@ class Observer : protected REACT_IMPL::ObserverInternals
     }
 
     template <typename F, typename T, typename ... Us>
-    auto CreateSyncedEventObserverNode(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... syncs) -> decltype(auto)
+    static auto CreateSyncedEventObserverNode(const Group& group, F&& func, const Event<T>& dep, const State<Us>& ... syncs) -> decltype(auto)
     {
         using REACT_IMPL::SyncedEventObserverNode;
         return std::make_shared<SyncedEventObserverNode<typename std::decay<F>::type, T, Us ...>>(
diff --git a/include/react/state.h b/include/react/state.h
index 95d80b6c..6c93de6c 100644
--- a/include/react/state.h
+++ b/include/react/state.h
@@ -13,15 +13,13 @@
 #include "react/api.h"
 #include "react/group.h"
 #include "react/common/ptrcache.h"
+#include "react/detail/state_nodes.h"
 
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
-#include "react/detail/state_nodes.h"
-
-
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -31,23 +29,23 @@ template <typename S>
 class State : protected REACT_IMPL::StateInternals<S>
 {
 public:
-    State(const State&) = default;
-    State& operator=(const State&) = default;
-
-    State(State&&) = default;
-    State& operator=(State&&) = default;
-
     // Construct with explicit group
     template <typename F, typename T1, typename ... Ts>
-    explicit State(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) :
-        State::StateInternals( CreateFuncNode(group, std::forward<F>(func), dep1, deps ...) )
-    { }
+    static State Create(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps)
+        { return CreateFuncNode(group, std::forward<F>(func), dep1, deps ...); }
 
     // Construct with implicit group
     template <typename F, typename T1, typename ... Ts>
-    explicit State(F&& func, const State<T1>& dep1, const State<Ts>& ... deps) :
-        State::StateInternals( CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...) )
-    { }
+    static State Create(F&& func, const State<T1>& dep1, const State<Ts>& ... deps)
+        { return CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...); }
+
+    State() = default;
+
+    State(const State&) = default;
+    State& operator=(const State&) = default;
+
+    State(State&&) = default;
+    State& operator=(State&&) = default;
 
     auto GetGroup() const -> const Group&
         { return this->GetNodePtr()->GetGroup(); }
@@ -68,13 +66,13 @@ class State : protected REACT_IMPL::StateInternals<S>
         { return s; }
 
 protected:
-    explicit State(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+    State(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
         State::StateInternals( std::move(nodePtr) )
     { }
 
 private:
     template <typename F, typename T1, typename ... Ts>
-    auto CreateFuncNode(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) -> decltype(auto)
+    static auto CreateFuncNode(const Group& group, F&& func, const State<T1>& dep1, const State<Ts>& ... deps) -> decltype(auto)
     {
         using REACT_IMPL::StateFuncNode;
         using REACT_IMPL::SameGroupOrLink;
@@ -94,23 +92,23 @@ template <typename S>
 class StateVar : public State<S>
 {
 public:
+    // Construct with group + default
+    static StateVar Create(const Group& group)
+        { return CreateVarNode(group); }
+
+    // Construct with group + value
+    template <typename T>
+    static StateVar Create(const Group& group, T&& value)
+        { return CreateVarNode(group, std::forward<T>(value)); }
+
+    StateVar() = default;
+
     StateVar(const StateVar&) = default;
     StateVar& operator=(const StateVar&) = default;
 
     StateVar(StateVar&&) = default;
     StateVar& operator=(StateVar&&) = default;
 
-    // Construct with group + default
-    explicit StateVar(const Group& group) :
-        StateVar::State( CreateVarNode(group) )
-    { }
-
-    // Construct with group + value
-    template <typename T>
-    StateVar(const Group& group, T&& value) :
-        StateVar::State( CreateVarNode(group, std::forward<T>(value)) )
-    { }
-
     void Set(const S& newValue)
         { SetValue(newValue); }
 
@@ -128,7 +126,7 @@ class StateVar : public State<S>
         { return !(a == b); }
 
 protected:
-    explicit StateVar(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+    StateVar(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
         StateVar::State( std::move(nodePtr) )
     { }
 
@@ -182,22 +180,22 @@ template <typename S>
 class StateSlot : public State<S>
 {
 public:
+    // Construct with explicit group
+    static StateSlot Create(const Group& group, const State<S>& input)
+        { return CreateSlotNode(group, input); }
+
+    // Construct with implicit group
+    static StateSlot Create(const State<S>& input)
+        { return CreateSlotNode(input.GetGroup(), input); }
+
+    StateSlot() = default;
+
     StateSlot(const StateSlot&) = default;
     StateSlot& operator=(const StateSlot&) = default;
 
     StateSlot(StateSlot&&) = default;
     StateSlot& operator=(StateSlot&&) = default;
 
-    // Construct with explicit group
-    StateSlot(const Group& group, const State<S>& input) :
-        StateSlot::State( CreateSlotNode(group, input) )
-    { }
-
-    // Construct with implicit group
-    explicit StateSlot(const State<S>& input) :
-        StateSlot::State( CreateSlotNode(input.GetGroup(), input) )
-    { }
-
     void Set(const State<S>& newInput)
         { SetInput(newInput); }
 
@@ -205,7 +203,7 @@ class StateSlot : public State<S>
         { SetInput(newInput); }
 
 protected:
-    explicit StateSlot(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+    StateSlot(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
         StateSlot::State( std::move(nodePtr) )
     { }
 
@@ -240,18 +238,24 @@ template <typename S>
 class StateLink : public State<S>
 {
 public:
+    // Construct with group
+    static StateLink Create(const Group& group, const State<S>& input)
+        { return GetOrCreateLinkNode(group, input); }
+
+    StateLink() = default;
+
     StateLink(const StateLink&) = default;
     StateLink& operator=(const StateLink&) = default;
 
     StateLink(StateLink&&) = default;
     StateLink& operator=(StateLink&&) = default;
 
-    // Construct with group
-    StateLink(const Group& group, const State<S>& input) :
-        StateLink::State( GetOrCreateLinkNode(group, input) )
+protected:
+    StateLink(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
+        StateLink::State( std::move(nodePtr) )
     { }
 
-protected:
+private:
     static auto GetOrCreateLinkNode(const Group& group, const State<S>& input) -> decltype(auto)
     {
         using REACT_IMPL::StateLinkNode;
@@ -262,9 +266,7 @@ class StateLink : public State<S>
 
         ReactGraph::LinkCache& linkCache = GetInternals(group).GetGraphPtr()->GetLinkCache();
 
-        std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(
-            k,
-            [&]
+        std::shared_ptr<IReactNode> nodePtr = linkCache.LookupOrCreate(k, [&]
             {
                 auto nodePtr = std::make_shared<StateLinkNode<S>>(group, input);
                 nodePtr->SetWeakSelfPtr(std::weak_ptr<StateLinkNode<S>>{ nodePtr });
@@ -275,19 +277,97 @@ class StateLink : public State<S>
     }
 };
 
-/******************************************/ REACT_END /******************************************/
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// ObjectContext
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class ObjectContext
+{
+public:
+    ObjectContext() = default;
+
+    ObjectContext(const ObjectContext&) = default;
+    ObjectContext& operator=(const ObjectContext&) = default;
+
+    ObjectContext(ObjectContext&&) = default;
+    ObjectContext& operator=(ObjectContext&&) = default;
+
+    const S& GetObject() const
+        { return object_; }
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
+    template <typename U>
+    const U& Get(const State<U>& member) const
+        { return GetInternals(member).Value(); }
 
+    template <typename U>
+    const EventValueList<U>& Get(const Event<U>& member) const
+        { return GetInternals(member).Events(); }
+
+private:
+    template <typename ... Us>
+    explicit ObjectContext(Us&& ... args) :
+        object_( std::forward<Us>(args) ... )
+    { }
+
+    S object_;
+
+    template <typename U>
+    friend class impl::StateNode;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// ObjectState
+///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S>
-static State<S> SameGroupOrLink(const Group& targetGroup, const State<S>& dep)
+class ObjectState : public State<ObjectContext<S>>
 {
-    if (dep.GetGroup() == targetGroup)
-        return dep;
-    else
-        return StateLink<S>( targetGroup, dep );
-}
+public:
+    // Construct with group
+    template <typename ... Us>
+    static ObjectState Create(const Group& group, S&& obj, const Us& ... members)
+    {
+        using REACT_IMPL::NodeId;
+
+        std::initializer_list<NodeId> memberIds = { GetInternals(members).GetNodeId() ... };
+
+        return CreateObjectStateNode(group, std::move(obj), memberIds);
+    }
+
+    template <typename ... Us>
+    static ObjectState Create(InPlaceTag, const Group& group, Us&& ... args)
+        { return CreateObjectStateNode(in_place, group, std::forward<Us>(args) ...); }
+
+    ObjectState() = default;
 
-/****************************************/ REACT_IMPL_END /***************************************/
+    ObjectState(const ObjectState&) = default;
+    ObjectState& operator=(const ObjectState&) = default;
+
+    ObjectState(ObjectState&&) = default;
+    ObjectState& operator=(ObjectState&&) = default;
+
+protected:
+    ObjectState(std::shared_ptr<REACT_IMPL::StateNode<ObjectContext<S>>>&& nodePtr) :
+        ObjectState::State( std::move(nodePtr) )
+    { }
+
+private:
+    static auto CreateObjectStateNode(const Group& group, S&& obj, const std::initializer_list<REACT_IMPL::NodeId>& memberIds) -> decltype(auto)
+    {
+        using REACT_IMPL::ObjectStateNode;
+
+        return std::make_shared<ObjectStateNode<S>>(group, std::move(obj), memberIds);
+    }
+
+    template <typename ... Us>
+    static auto CreateObjectStateNode(InPlaceTag, const Group& group, Us&& ... args) -> decltype(auto)
+    {
+        using REACT_IMPL::ObjectStateNode;
+        using REACT_IMPL::SameGroupOrLink;
+
+        return std::make_shared<ObjectStateNode<S>>(in_place, group, std::forward<Us>(args) ...);
+    }
+};
+
+/******************************************/ REACT_END /******************************************/
 
 #endif // REACT_STATE_H_INCLUDED
\ No newline at end of file
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 1867d880..088c482f 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -22,6 +22,7 @@
     <ProjectGuid>{5E56AAB9-4E33-4B9E-A315-E85CEDB75CF1}</ProjectGuid>
     <RootNamespace>CppReact</RootNamespace>
     <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <ProjectName>CppReact</ProjectName>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 1946c5e0..82b7e451 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -9,15 +9,11 @@ add_subdirectory($ENV{GTEST_DIR} ${CMAKE_CURRENT_BINARY_DIR}/gtest)
 
 ### CppReactTest
 add_executable(CppReactTest
-	src/EventStreamTest.cpp
-	src/EventStreamTestQ.cpp
-	src/MoveTest.cpp
-	src/ObserverTest.cpp
-	src/ObserverTestQ.cpp
-	src/OperationsTest.cpp
-	src/OperationsTestQ.cpp
-	src/SignalTest.cpp
-	src/SignalTestQ.cpp
-	src/TransactionTest.cpp)
+	src/algorithm_tests.cpp
+	src/common_tests.cpp
+	src/event_tests.cpp
+	src/observer_tests.cpp
+	src/state_tests.cpp
+	src/transaction_tests.cpp)
 
 target_link_libraries(CppReactTest CppReact gtest gtest_main)
diff --git a/tests/src/algorithm_tests.cpp b/tests/src/algorithm_tests.cpp
index 49bd221c..32cac388 100644
--- a/tests/src/algorithm_tests.cpp
+++ b/tests/src/algorithm_tests.cpp
@@ -24,14 +24,14 @@ TEST(AlgorithmTest, Hold)
 
     Group g;
 
-    EventSource<int> evt1( g );
+    auto evt1 = EventSource<int>::Create(g);
 
     State<int> st = Hold(1, evt1);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (int v)
+    auto obs = Observer::Create([&] (int v)
         {
             ++turns;
             output = v;
@@ -60,14 +60,14 @@ TEST(AlgorithmTest, Monitor1)
 
     Group g;
 
-    StateVar<int> st( g, 1 );
+    auto st = StateVar<int>::Create(g, 1);
 
     Event<int> evt = Monitor( st );
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             ++turns;
 
@@ -98,7 +98,7 @@ TEST(AlgorithmTest, Monitor2)
 
     Group g;
 
-    StateVar<int> target( g, 10 );
+    auto target = StateVar<int>::Create(g, 10);
 
     std::vector<int> results;
 
@@ -107,7 +107,7 @@ TEST(AlgorithmTest, Monitor2)
     {
         // Observer is created in a nested scope so it gets destructed before the end of this function.
 
-        Observer obs([&] (const auto& events)
+        auto obs = Observer::Create([&] (const auto& events)
             {
                 for (int e : events)
                     results.push_back(e);
@@ -134,15 +134,15 @@ TEST(AlgorithmTest, Snapshot)
 {
     Group g;
 
-    StateVar<int> sv( g, 1 );
-    EventSource<> es( g );
+    auto sv = StateVar<int>::Create(g, 1);
+    auto es = EventSource<>::Create(g);
 
     State<int> st = Snapshot( sv, es );
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (int v)
+    auto obs = Observer::Create([&] (int v)
         {
             ++turns;
             output = v;
@@ -166,15 +166,15 @@ TEST(AlgorithmTest, Pulse)
 {
     Group g;
 
-    StateVar<int> sv( g, 1 );
-    EventSource<> es( g );
+    auto sv = StateVar<int>::Create(g, 1);
+    auto es = EventSource<>::Create(g);
 
     Event<int> st = Pulse( sv, es );
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             for (int e : events)
             {
@@ -201,7 +201,7 @@ TEST(AlgorithmTest, Iterate1)
 {
     Group g;
 
-    EventSource<int> numSrc( g );
+    auto numSrc = EventSource<int>::Create(g);
 
     State<int> numFold = Iterate<int>(0, [] (const auto& events, int v)
         {
@@ -214,7 +214,7 @@ TEST(AlgorithmTest, Iterate1)
         numSrc << i;
 
     int output = 0;
-    Observer obs([&] (int v) { output = v; }, numFold);
+    auto obs = Observer::Create([&] (int v) { output = v; }, numFold);
 
     EXPECT_EQ(output, 5050);
 }
@@ -223,7 +223,7 @@ TEST(AlgorithmTest, Iterate2)
 {
     Group g;
 
-    EventSource<char> charSrc( g );
+    auto charSrc = EventSource<char>::Create(g);
 
     State<std::string> strFold = Iterate<std::string>(std::string(""), [] (const auto& events, std::string s)
         {
@@ -233,7 +233,7 @@ TEST(AlgorithmTest, Iterate2)
         }, charSrc);
 
     std::string output;
-    Observer obs([&] (const auto& v) { output = v; }, strFold);
+    auto obs = Observer::Create([&] (const auto& v) { output = v; }, strFold);
 
     charSrc << 'T' << 'e' << 's' << 't';
 
@@ -244,7 +244,7 @@ TEST(AlgorithmTest, Iterate3)
 {
     Group g;
 
-    EventSource<int> numSrc( g );
+    auto numSrc = EventSource<int>::Create(g);
 
     State<int> numFold = Iterate<int>(0, [] (const auto& events, int v)
         {
@@ -256,7 +256,7 @@ TEST(AlgorithmTest, Iterate3)
     int turns = 0;
     int output = 0;
 
-    Observer obs([&] (const auto& v)
+    auto obs = Observer::Create([&] (const auto& v)
         {
             ++turns;
             output = v;
@@ -298,7 +298,7 @@ TEST(AlgorithmTest, Iterate4)
 {
     Group g;
 
-    EventSource<> trigger( g );
+    auto trigger = EventSource<>::Create(g);
 
     {
         State<int> inc = Iterate<int>(0, Incrementer<int>{ }, trigger);
@@ -306,7 +306,7 @@ TEST(AlgorithmTest, Iterate4)
             trigger.Emit();
 
         int output = 0;
-        Observer obs([&] (int v) { output = v; }, inc);
+        auto obs = Observer::Create([&] (int v) { output = v; }, inc);
 
         EXPECT_EQ(output, 100);
     }
@@ -317,7 +317,7 @@ TEST(AlgorithmTest, Iterate4)
             trigger.Emit();
 
         int output = 0;
-        Observer obs([&] (int v) { output = v; }, dec);
+        auto obs = Observer::Create([&] (int v) { output = v; }, dec);
 
         ASSERT_EQ(output, 100);
     }
@@ -327,7 +327,7 @@ TEST(AlgorithmTest, IterateByRef1)
 {
     Group g;
 
-    EventSource<int> src( g );
+    auto src = EventSource<int>::Create(g);
 
     auto x = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, auto& v)
         {
@@ -336,7 +336,7 @@ TEST(AlgorithmTest, IterateByRef1)
         }, src);
 
     std::vector<int> output;
-    Observer obs([&] (const auto& v) { output = v; }, x);
+    auto obs = Observer::Create([&] (const auto& v) { output = v; }, x);
 
     // Push
     for (int i=1; i<=100; i++)
@@ -353,7 +353,7 @@ TEST(AlgorithmTest, IterateByRef2)
 {
     Group g;
 
-    EventSource<> src( g );
+    auto src = EventSource<>::Create(g);
 
     auto x = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, std::vector<int>& v)
         {
@@ -362,7 +362,7 @@ TEST(AlgorithmTest, IterateByRef2)
         }, src);
 
     std::vector<int> output;
-    Observer obs([&] (const auto& v) { output = v; }, x);
+    auto obs = Observer::Create([&] (const auto& v) { output = v; }, x);
 
     // Push
     for (auto i=0; i<100; i++)
@@ -392,15 +392,15 @@ TEST(AlgorithmTest, TransformWithState)
 {
     Group g;
 
-    StateVar<int> in1( g );
-    StateVar<int> in2( g );
+    auto in1 = StateVar<int>::Create(g);
+    auto in2 = StateVar<int>::Create(g);
 
-    State<int> sum( Sum<int>, in1, in2 );
-    State<int> prod( Prod<int>, in1, in2 );
-    State<int> diff( Diff<int>, in1, in2 );
+    auto sum  = State<int>::Create(Sum<int>, in1, in2);
+    auto prod = State<int>::Create(Prod<int>, in1, in2);
+    auto diff = State<int>::Create(Diff<int>, in1, in2);
 
-    EventSource<> src1( g );
-    EventSource<int> src2( g );
+    auto src1 = EventSource<>::Create(g);
+    auto src2 = EventSource<int>::Create(g);
 
     auto out1 = Transform<std::tuple<int, int, int>>([] (Token, int sum, int prod, int diff)
         {
@@ -418,7 +418,7 @@ TEST(AlgorithmTest, TransformWithState)
     {
         std::tuple<int, int, int> output1;
 
-        Observer obs1([&] (const auto& events)
+        auto obs1 = Observer::Create([&] (const auto& events)
             {
                 for (const auto& e : events)
                 {
@@ -429,7 +429,7 @@ TEST(AlgorithmTest, TransformWithState)
 
         std::tuple<int, int, int, int> output2;
 
-        Observer obs2([&] (const auto& events)
+        auto obs2 = Observer::Create([&] (const auto& events)
             {
                 for (const auto& e : events)
                 {
@@ -460,7 +460,7 @@ TEST(AlgorithmTest, TransformWithState)
     {
         std::tuple<int, int, int> output1;
 
-        Observer obs1([&] (const auto& events)
+        auto obs1 = Observer::Create([&] (const auto& events)
             {
                 for (const auto& e : events)
                 {
@@ -471,7 +471,7 @@ TEST(AlgorithmTest, TransformWithState)
 
         std::tuple<int, int, int, int> output2;
 
-        Observer obs2([&] (const auto& events)
+        auto obs2 = Observer::Create([&] (const auto& events)
             {
                 for (const auto& e : events)
                 {
@@ -504,14 +504,14 @@ TEST(AlgorithmTest, IterateWithState)
 {
     Group g;
 
-    StateVar<int> in1( g );
-    StateVar<int> in2( g );
+    auto in1 = StateVar<int>::Create(g);
+    auto in2 = StateVar<int>::Create(g);
 
-    State<int> op1(Sum<int>, in1, in2);
-    State<int> op2([] (int a, int b) { return (a + b) * 10; }, in1, in2);
+    auto op1 = State<int>::Create(Sum<int>, in1, in2);
+    auto op2 = State<int>::Create([] (int a, int b) { return (a + b) * 10; }, in1, in2);
 
-    EventSource<> src1( g );
-    EventSource<int> src2( g );
+    auto src1 = EventSource<>::Create(g);
+    auto src2 = EventSource<int>::Create(g);
 
     auto out1 = Iterate<std::tuple<int, int>>(std::make_tuple(0, 0), [] (const auto& events, std::tuple<int, int> t, int op1, int op2)
         {
@@ -536,7 +536,7 @@ TEST(AlgorithmTest, IterateWithState)
     {
         std::tuple<int, int> output1;
 
-        Observer obs1([&] (const auto& v)
+        auto obs1 = Observer::Create([&] (const auto& v)
             {
                 ++turns1;
                 output1 = v;
@@ -544,7 +544,7 @@ TEST(AlgorithmTest, IterateWithState)
 
         std::tuple<int, int, int> output2;
 
-        Observer obs2([&] (const auto& v)
+        auto obs2 = Observer::Create([&] (const auto& v)
             {
                 ++turns2;
                 output2 = v;
@@ -570,7 +570,7 @@ TEST(AlgorithmTest, IterateWithState)
     {
         std::tuple<int, int> output1;
 
-        Observer obs1([&] (const auto& v)
+        auto obs1 = Observer::Create([&] (const auto& v)
             {
                 ++turns1;
                 output1 = v;
@@ -578,7 +578,7 @@ TEST(AlgorithmTest, IterateWithState)
 
         std::tuple<int, int, int> output2;
 
-        Observer obs2([&] (const auto& v)
+        auto obs2 = Observer::Create([&] (const auto& v)
             {
                 ++turns2;
                 output2 = v;
@@ -606,14 +606,14 @@ TEST(AlgorithmTest, IterateByRefWithState)
 {
     Group g;
 
-    StateVar<int> in1( g );
-    StateVar<int> in2( g );
+    auto in1 = StateVar<int>::Create(g);
+    auto in2 = StateVar<int>::Create(g);
 
-    State<int> op1( Sum<int>, in1, in2 );
-    State<int> op2([] (int a, int b) { return (a + b) * 10; }, in1, in2);
+    auto op1 = State<int>::Create(Sum<int>, in1, in2);
+    auto op2 = State<int>::Create([] (int a, int b) { return (a + b) * 10; }, in1, in2);
 
-    EventSource<> src1( g );
-    EventSource<int> src2( g );
+    auto src1 = EventSource<>::Create(g);
+    auto src2 = EventSource<int>::Create(g);
 
     auto out1 = IterateByRef<std::vector<int>>(std::vector<int>{ }, [] (const auto& events, std::vector<int>& v, int op1, int op2)
         {
@@ -640,7 +640,7 @@ TEST(AlgorithmTest, IterateByRefWithState)
     {
         std::vector<int> output1;
 
-        Observer obs1([&] (const std::vector<int>& v)
+        auto obs1 = Observer::Create([&] (const std::vector<int>& v)
             {
                 ++turns1;
                 output1 = v;
@@ -648,7 +648,7 @@ TEST(AlgorithmTest, IterateByRefWithState)
 
         std::vector<int> output2;
 
-        Observer obs2([&] (const std::vector<int>& v)
+        auto obs2 = Observer::Create([&] (const std::vector<int>& v)
             {
                 ++turns2;
                 output2 = v;
@@ -676,7 +676,7 @@ TEST(AlgorithmTest, IterateByRefWithState)
     {
         std::vector<int> output1;
 
-        Observer obs1([&] (const std::vector<int>& v)
+        auto obs1 = Observer::Create([&] (const std::vector<int>& v)
             {
                 ++turns1;
                 output1 = v;
@@ -684,7 +684,7 @@ TEST(AlgorithmTest, IterateByRefWithState)
 
         std::vector<int> output2;
 
-        Observer obs2([&] (const std::vector<int>& v)
+        auto obs2 = Observer::Create([&] (const std::vector<int>& v)
             {
                 ++turns2;
                 output2 = v;
diff --git a/tests/src/event_tests.cpp b/tests/src/event_tests.cpp
index 168ac619..c4a3200c 100644
--- a/tests/src/event_tests.cpp
+++ b/tests/src/event_tests.cpp
@@ -25,7 +25,7 @@ TEST(EventTest, Construction)
 
     // Event source
     {
-        EventSource<int> t1( g );
+        auto t1 = EventSource<int>::Create(g);
         EventSource<int> t2( t1 );
         EventSource<int> t3( std::move(t1) );
         
@@ -37,7 +37,7 @@ TEST(EventTest, Construction)
 
     // Event slot
     {
-        EventSlot<int> t1( g );
+        auto t1 = EventSlot<int>::Create(g);
         EventSlot<int> t2( t1 );
         EventSlot<int> t3( std::move(t1) );
         
@@ -49,9 +49,9 @@ TEST(EventTest, Construction)
 
     // Event link
     {
-        EventSlot<int> s1( g );
+        auto s1 = EventSlot<int>::Create(g);
 
-        EventLink<int> t1( g, s1 );
+        auto t1 = EventLink<int>::Create(g, s1);
         EventLink<int> t2( t1 );
         EventLink<int> t3( std::move(t1) );
         
@@ -66,11 +66,11 @@ TEST(EventTest, BasicOutput)
 {
     Group g;
 
-    EventSource<int> evt( g );
+    auto evt = EventSource<int>::Create(g);
 
     int output = 0;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             for (int e : events)
                 output += e;
@@ -89,15 +89,15 @@ TEST(EventTest, Slots)
 {
     Group g;
 
-    EventSource<int> evt1( g );
-    EventSource<int> evt2( g );
+    auto evt1 = EventSource<int>::Create(g);
+    auto evt2 = EventSource<int>::Create(g);
 
-    EventSlot<int> slot( g );
+    auto slot = EventSlot<int>::Create(g);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             ++turns;
 
@@ -153,12 +153,12 @@ TEST(EventTest, Transactions)
 {
     Group g;
 
-    EventSource<int> evt( g );
+    auto evt = EventSource<int>::Create(g);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             ++turns;
             for (int e : events)
@@ -182,17 +182,17 @@ TEST(EventTest, Links)
     Group g2;
     Group g3;
 
-    EventSource<int> evt1( g1 );
-    EventSource<int> evt2( g2 );
-    EventSource<int> evt3( g3 );
+    auto evt1 = EventSource<int>::Create(g1);
+    auto evt2 = EventSource<int>::Create(g2);
+    auto evt3 = EventSource<int>::Create(g3);
 
-    EventSlot<int> slot( g1 );
+    auto slot = EventSlot<int>::Create(g1);
 
     // Same group
     slot.Add(evt1);
 
     // Explicit link
-    EventLink<int> lnk2( g1, evt2 );
+    auto lnk2 = EventLink<int>::Create(g1, evt2);
     slot.Add(lnk2);
 
     // Implicit link
@@ -203,7 +203,7 @@ TEST(EventTest, Links)
 
     EXPECT_EQ(0, output);
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             ++turns;
             for (int e : events)
@@ -224,19 +224,19 @@ TEST(EventTest, EventSources)
 {
     Group g;
 
-    EventSource<int> es1( g );
-    EventSource<int> es2( g );
+    auto es1 = EventSource<int>::Create(g);
+    auto es2 = EventSource<int>::Create(g);
 
     std::queue<int> results1;
     std::queue<int> results2;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (int e : events)
                 results1.push(e);
         }, es1);
 
-    Observer obs2([&] (const auto& events)
+    auto obs2 = Observer::Create([&] (const auto& events)
         {
             for (int e : events)
                 results2.push(e);
@@ -280,15 +280,15 @@ TEST(EventTest, Merge1)
 {
     Group g;
 
-    EventSource<int> a1( g );
-    EventSource<int> a2( g );
-    EventSource<int> a3( g );
+    auto a1 = EventSource<int>::Create(g);
+    auto a2 = EventSource<int>::Create(g);
+    auto a3 = EventSource<int>::Create(g);
 
     Event<int> merged = Merge(g, a1, a2, a3);
 
     std::vector<int> results;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (int e : events)
                 results.push_back(e);
@@ -312,15 +312,15 @@ TEST(EventTest, Merge2)
 {
     Group g;
 
-    EventSource<std::string> a1( g );
-    EventSource<std::string> a2( g );
-    EventSource<std::string> a3( g );
+    auto a1 = EventSource<std::string>::Create(g);
+    auto a2 = EventSource<std::string>::Create(g);
+    auto a3 = EventSource<std::string>::Create(g);
 
     Event<std::string> merged = Merge(a1, a2, a3);
 
     std::vector<std::string> results;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (const auto& e : events)
                 results.push_back(e);
@@ -348,8 +348,8 @@ TEST(EventTest, Merge3)
 {
     Group g;
 
-    EventSource<int> a1( g );
-    EventSource<int> a2( g );
+    auto a1 = EventSource<int>::Create(g);
+    auto a2 = EventSource<int>::Create(g);
 
     Event<int> f1 = Filter([] (int v) { return true; }, a1);
     Event<int> f2 = Filter([] (int v) { return true; }, a2);
@@ -358,7 +358,7 @@ TEST(EventTest, Merge3)
 
     std::queue<int> results;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (int e : events)
                 results.push(e);
@@ -387,7 +387,7 @@ TEST(EventTest, Filter)
 {
     Group g;
 
-    EventSource<std::string> in( g );
+    auto in = EventSource<std::string>::Create(g);
 
     std::queue<std::string> results;
 
@@ -396,7 +396,7 @@ TEST(EventTest, Filter)
             return s == "Hello World";
         }, in);
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (const auto& e : events)
                 results.push(e);
@@ -417,8 +417,8 @@ TEST(EventTest, Transform)
 {
     Group g;
 
-    EventSource<std::string> in1( g );
-    EventSource<std::string> in2( g );
+    auto in1 = EventSource<std::string>::Create(g);
+    auto in2 = EventSource<std::string>::Create(g);
 
     std::vector<std::string> results;
 
@@ -430,7 +430,7 @@ TEST(EventTest, Transform)
             return s;
         }, merged);
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (const auto& e : events)
                 results.push_back(e);
@@ -452,13 +452,13 @@ TEST(EventTest, Flow)
 
     std::vector<float> results;
 
-    EventSource<int> in1( g );
-    EventSource<int> in2( g );
+    auto in1 = EventSource<int>::Create(g);
+    auto in2 = EventSource<int>::Create(g);
 
     auto merged = Merge(in1, in2);
     int turns = 0;
 
-    Event<float> processed([&] (const auto& events, auto out)
+    auto processed = Event<float>::Create([&] (const auto& events, auto out)
         {
             for (const auto& e : events)
             {
@@ -469,7 +469,7 @@ TEST(EventTest, Flow)
             ++turns;
         }, merged);
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (float e : events)
                 results.push_back(e);
@@ -497,15 +497,15 @@ TEST(EventTest, Join)
 {
     Group g;
 
-    EventSource<int> in1( g );
-    EventSource<int> in2( g );
-    EventSource<int> in3( g );
+    auto in1 = EventSource<int>::Create(g);
+    auto in2 = EventSource<int>::Create(g);
+    auto in3 = EventSource<int>::Create(g);
 
     Event<std::tuple<int, int, int>> joined = Join(in1, in2, in3);
 
     std::vector<std::tuple<int, int, int>> results;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             for (const auto& e : events)
                 results.push_back(e);
@@ -536,12 +536,12 @@ TEST(EventTest, FilterWithState)
 {
     Group g;
 
-    EventSource<std::string> in( g );
+    auto in = EventSource<std::string>::Create(g);
 
-    StateVar<int> sig1( g, 1338 );
-    StateVar<int> sig2( g, 1336 );
+    auto sig1 = StateVar<int>::Create(g, 1338);
+    auto sig2 = StateVar<int>::Create(g, 1336);
 
-    EventSource<int> in2( g );
+    auto in2 = EventSource<int>::Create(g);
 
     auto filtered = Filter([] (const std::string& s, int sig1, int sig2)
         {
@@ -550,7 +550,7 @@ TEST(EventTest, FilterWithState)
 
     std::queue<std::string> results;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             for (const auto& e : events)
                 results.push(e);
@@ -573,13 +573,13 @@ TEST(EventTest, TransformWithState)
 
     std::vector<std::string> results;
 
-    EventSource<std::string> in1( g );
-    EventSource<std::string> in2( g );
+    auto in1 = EventSource<std::string>::Create(g);
+    auto in2 = EventSource<std::string>::Create(g);
 
     Event<std::string> merged = Merge(in1, in2);
 
-    StateVar<std::string> first( g, "Ace" );
-    StateVar<std::string> last( g, "McSteele" );
+    auto first = StateVar<std::string>::Create(g, "Ace");
+    auto last =  StateVar<std::string>::Create(g, "McSteele");
 
     auto transformed = Transform<std::string>([] (std::string s, const std::string& first, const std::string& last) -> std::string
         {
@@ -588,7 +588,7 @@ TEST(EventTest, TransformWithState)
             return s;
         }, merged, first, last);
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             for (const auto& e : events)
                 results.push_back(e);
@@ -615,15 +615,15 @@ TEST(EventTest, FlowWithState)
 
     std::vector<float> results;
 
-    EventSource<int> in1( g );
-    EventSource<int> in2( g );
+    auto in1 = EventSource<int>::Create(g);
+    auto in2 = EventSource<int>::Create(g);
 
-    StateVar<int> mult( g, 10 );
+    auto mult = StateVar<int>::Create(g, 10);
 
     Event<int> merged = Merge(in1, in2);
     int callCount = 0;
 
-    Event<float> processed([&] (const auto& events, auto out, int mult)
+    auto processed = Event<float>::Create([&] (const auto& events, auto out, int mult)
         {
             for (const auto& e : events)
             {
@@ -634,7 +634,7 @@ TEST(EventTest, FlowWithState)
             callCount++;
         }, merged, mult);
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             for (float e : events)
                 results.push_back(e);
diff --git a/tests/src/state_tests.cpp b/tests/src/state_tests.cpp
index 953cedc8..10e41205 100644
--- a/tests/src/state_tests.cpp
+++ b/tests/src/state_tests.cpp
@@ -20,7 +20,7 @@ TEST(StateTest, Construction)
 
     // State variable
     {
-        StateVar<int> t1( g, 0 );
+        auto t1 = StateVar<int>::Create(g, 0);
         StateVar<int> t2( t1 );
         StateVar<int> t3( std::move(t1) );
         
@@ -32,9 +32,9 @@ TEST(StateTest, Construction)
 
     // State slot
     {
-        StateVar<int> t0( g, 0 );
+        auto t0 = StateVar<int>::Create(g, 0);
 
-        StateSlot<int> t1( g, t0 );
+        auto t1 = StateSlot<int>::Create(g, t0);
         StateSlot<int> t2( t1 );
         StateSlot<int> t3( std::move(t1) );
         
@@ -46,11 +46,11 @@ TEST(StateTest, Construction)
 
     // State link
     {
-        StateVar<int> t0( g, 0 );
+        auto t0 = StateVar<int>::Create(g, 0);
 
-        StateSlot<int> s1( g, t0 );
+        auto s1 = StateSlot<int>::Create(g, t0);
 
-        StateLink<int> t1( g, s1 );
+        auto t1 = StateLink<int>::Create(g, s1);
         StateLink<int> t2( t1 );
         StateLink<int> t3( std::move(t1) );
         
@@ -65,11 +65,11 @@ TEST(StateTest, BasicOutput)
 {
     Group g;
 
-    StateVar<int> st( g );
+    auto st = StateVar<int>::Create(g);
 
     int output = 0;
 
-    Observer obs([&] (const auto& v)
+    auto obs2 = Observer::Create([&] (const auto& v)
         {
             output += v;
         }, st);
@@ -87,15 +87,15 @@ TEST(StateTest, Slots)
 {
     Group g;
 
-    StateVar<int> st1( g );
-    StateVar<int> st2( g );
+    auto st1 = StateVar<int>::Create(g);
+    auto st2 = StateVar<int>::Create(g);
 
-    StateSlot<int> slot( g, st1 );
+    auto slot = StateSlot<int>::Create(g, st1);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& v)
+    auto obs = Observer::Create([&] (const auto& v)
         {
             ++turns;
             output += v;
@@ -125,12 +125,12 @@ TEST(StateTest, Transactions)
 {
     Group g;
 
-    StateVar<int> st( g, 1 );
+    auto st = StateVar<int>::Create(g, 1);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& v)
+    auto obs = Observer::Create([&] (const auto& v)
         {
             ++turns;
             output += v;
@@ -156,16 +156,16 @@ TEST(StateTest, Links)
     Group g2;
     Group g3;
 
-    StateVar<int> st1( g1, 1 );
-    StateVar<int> st2( g2, 2 );
-    StateVar<int> st3( g3, 3 );
+    auto st1 = StateVar<int>::Create(g1, 1);
+    auto st2 = StateVar<int>::Create(g2, 2);
+    auto st3 = StateVar<int>::Create(g3, 3);
 
-    StateSlot<int> slot( g1, st1 );
+    auto slot = StateSlot<int>::Create(g1, st1);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& v)
+    auto obs = Observer::Create([&] (const auto& v)
         {
             ++turns;
             output = v;
@@ -177,7 +177,7 @@ TEST(StateTest, Links)
     EXPECT_EQ(2, turns);
 
     // Explicit link
-    StateLink<int> lnk2( g1, st2 );
+    auto lnk2 = StateLink<int>::Create(g1, st2);
     slot.Set(lnk2);
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(2, output);
@@ -223,21 +223,21 @@ TEST(StateTest, StateCombination1)
 {
     Group g;
 
-    StateVar<int> a( g, 0 );
-    StateVar<int> b( g, 0 );
-    StateVar<int> c( g, 0 );
+    auto a = StateVar<int>::Create(g, 0);
+    auto b = StateVar<int>::Create(g, 0);
+    auto c = StateVar<int>::Create(g, 0);
 
-    State<int> s1(Sum2<int>, a, b);
+    auto s1 = State<int>::Create(Sum2<int>, a, b);
     
-    State<int> x(Sum2<int>, s1, c);
-    State<int> y(Sum3<int>, a, b, c);
+    auto x = State<int>::Create(Sum2<int>, s1, c);
+    auto y = State<int>::Create(Sum3<int>, a, b, c);
 
     int output1 = 0;
     int output2 = 0;
     int turns1 = 0;
     int turns2 = 0;
 
-    Observer obs1([&] (int v)
+    auto obs1 = Observer::Create([&] (int v)
         {
             ++turns1;
             output1 = v;
@@ -246,7 +246,7 @@ TEST(StateTest, StateCombination1)
     EXPECT_EQ(0, output1);
     EXPECT_EQ(1, turns1);
 
-    Observer obs2([&] (int v)
+    auto obs2 = Observer::Create([&] (int v)
         {
             ++turns2;
             output2 = v;
@@ -272,57 +272,57 @@ TEST(StateTest, StateCombination2)
 
     std::vector<int> results;
 
-    StateVar<int> n1( g, 1 );
+    auto n1 = StateVar<int>::Create(g, 1);
 
-    State<int> n2([] (int n1)
+    auto n2 = State<int>::Create([] (int n1)
         { return n1 + 1; }, n1);
 
-    State<int> n3([] (int n1, int n2)
+    auto n3 = State<int>::Create([] (int n1, int n2)
         { return n2 + n1 + 1; }, n1, n2);
 
-    State<int> n4([] (int n3)
+    auto n4 = State<int>::Create([] (int n3)
         { return n3 + 1; }, n3);
 
-    State<int> n5([] (int n1, int n3, int n4)
+    auto n5 = State<int>::Create([] (int n1, int n3, int n4)
         { return n4 + n3 + n1 + 1; }, n1, n3, n4);
 
-    State<int> n6([] (int n5)
+    auto n6 = State<int>::Create([] (int n5)
         { return n5 + 1; }, n5);
 
-    State<int> n7([] (int n5, int n6)
+    auto n7 = State<int>::Create([] (int n5, int n6)
         { return n6 + n5 + 1; }, n5, n6);
 
-    State<int> n8([] (int n7)
+    auto n8 = State<int>::Create([] (int n7)
         { return n7 + 1; }, n7);
 
-    State<int> n9([] (int n1, int n5, int n7, int n8)
+    auto n9 = State<int>::Create([] (int n1, int n5, int n7, int n8)
         { return n8 + n7 + n5 + n1 + 1; }, n1, n5, n7, n8);
 
-    State<int> n10([] (int n9)
+    auto n10 = State<int>::Create([] (int n9)
         { return n9 + 1; }, n9);
 
-    State<int> n11([] (int n9, int n10)
+    auto n11 = State<int>::Create([] (int n9, int n10)
         { return n10 + n9 + 1; }, n9, n10);
 
-    State<int> n12([] (int n11)
+    auto n12 = State<int>::Create([] (int n11)
         { return n11 + 1; }, n11);
 
-    State<int> n13([] (int n9, int n11, int n12)
+    auto n13 = State<int>::Create([] (int n9, int n11, int n12)
         { return n12 + n11 + n9 + 1; }, n9, n11, n12);
 
-    State<int> n14([] (int n13)
+    auto n14 = State<int>::Create([] (int n13)
         { return n13 + 1; }, n13);
 
-    State<int> n15([] (int n13, int n14)
+    auto n15 = State<int>::Create([] (int n13, int n14)
         { return n14 + n13 + 1; }, n13, n14);
 
-    State<int> n16([] (int n15)
+    auto n16 = State<int>::Create([] (int n15)
         { return n15 + 1; }, n15);
 
-    State<int> n17([] (int n9, int n13, int n15, int n16)
+    auto n17 = State<int>::Create([] (int n9, int n13, int n15, int n16)
         { return n16 + n15 + n13 + n9 + 1; }, n9, n13, n15, n16);
 
-    Observer obs([&] (int v) { results.push_back(v); }, n17);
+    auto obs = Observer::Create([&] (int v) { results.push_back(v); }, n17);
 
     n1.Set(10);     // 7732
     n1.Set(100);    // 68572
@@ -342,11 +342,11 @@ TEST(StateTest, Modify1)
 
     std::vector<int> results;
 
-    StateVar<std::vector<int>> var( g, std::vector<int>{ } );
+    auto var = StateVar<std::vector<int>>::Create(g, std::vector<int>{ });
 
     int turns = 0;
 
-    Observer obs([&] (const std::vector<int>& v)
+    auto obs = Observer::Create([&] (const std::vector<int>& v)
         {
             ++turns;
             results = v;
@@ -372,11 +372,11 @@ TEST(StateTest, Modify2)
 
     std::vector<int> results;
 
-    StateVar<std::vector<int>> var( g, std::vector<int>{ } );
+    auto var = StateVar<std::vector<int>>::Create(g, std::vector<int>{ });
 
     int turns = 0;
 
-    Observer obs([&] (const std::vector<int>& v)
+    auto obs = Observer::Create([&] (const std::vector<int>& v)
         {
             ++turns;
             results = v;
@@ -402,17 +402,16 @@ TEST(StateTest, Modify3)
 
     std::vector<int> results;
 
-    StateVar<std::vector<int>> var( g, std::vector<int>{ } );
+    auto var = StateVar<std::vector<int>>::Create(g, std::vector<int>{ });
 
     int turns = 0;
 
-    Observer obs([&] (const std::vector<int>& v)
+    auto obs = Observer::Create([&] (const std::vector<int>& v)
         {
             ++turns;
             results = v;
         }, var);
     
-    // Also terrible
     g.DoTransaction([&]
         {
             var.Set(std::vector<int>{ 30, 50 });
@@ -424,4 +423,58 @@ TEST(StateTest, Modify3)
     EXPECT_EQ(results[2], 70);
 
     ASSERT_EQ(turns, 2);
+}
+
+class Widget
+{
+public:
+    StateVar<int> color;
+
+    StateVar<int> width;
+    StateVar<int> height;
+
+    auto GetReactiveMembers() const -> decltype(auto)
+        { return std::tie(color, width, height); }
+
+    Widget(const Group& group)
+    {
+        color  = StateVar<int>::Create(group, 0);
+        width  = StateVar<int>::Create(group, 0);
+        height = StateVar<int>::Create(group, 0);
+    }
+
+    Widget(const Group& group, int value)
+    {
+        color  = StateVar<int>::Create(group, value);
+        width  = StateVar<int>::Create(group, value);
+        height = StateVar<int>::Create(group, value);
+    }
+
+    
+};
+
+TEST(StateTest, Object)
+{
+    Group g;
+
+    Widget w1( g );
+    Widget w2( g );
+
+    auto st1 = ObjectState<Widget>::Create(g, std::move(w1), w1.color, w1.width, w1.height);
+
+    auto st2 = ObjectState<Widget>::Create(in_place, g, 1337);
+
+    auto st3 = ObjectState<Widget>::Create(g, std::move(w2));
+
+    auto obs = Observer::Create([&] (const auto& ctx)
+        {
+            const Widget& widget = ctx.GetObject();
+
+            int color = ctx.Get(widget.color);
+            int width = ctx.Get(widget.width);
+            int height = ctx.Get(widget.height);
+        }, st1);
+
+    w1.color.Set(10);
+    w2.color.Set(20);
 }
\ No newline at end of file
diff --git a/tests/src/transaction_tests.cpp b/tests/src/transaction_tests.cpp
index 01e65ac9..6c0f8101 100644
--- a/tests/src/transaction_tests.cpp
+++ b/tests/src/transaction_tests.cpp
@@ -19,12 +19,12 @@ TEST(TransactionTest, Merging)
 {
     Group g;
 
-    EventSource<int> evt( g );
+    auto evt = EventSource<int>::Create(g);
 
     int output = 0;
     int turns = 0;
 
-    Observer obs([&] (const auto& events)
+    auto obs = Observer::Create([&] (const auto& events)
         {
             ++turns;
             for (int e : events)
@@ -78,12 +78,12 @@ TEST(TransactionTest, LinkedSync)
     Group g2;
     Group g3;
 
-    EventSource<int> evt1( g1 );
+    auto evt1 = EventSource<int>::Create(g1);
 
     int output1 = 0;
     int turns1 = 0;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             ++turns1;
             for (int e : events)
@@ -95,7 +95,7 @@ TEST(TransactionTest, LinkedSync)
     int output2 = 0;
     int turns2 = 0;
 
-    Observer obs2([&] (const auto& events)
+    auto obs2 = Observer::Create([&] (const auto& events)
         {
             ++turns2;
             for (int e : events)
@@ -107,7 +107,7 @@ TEST(TransactionTest, LinkedSync)
     int output3 = 0;
     int turns3 = 0;
 
-    Observer obs3([&] (const auto& events)
+    auto obs3 = Observer::Create([&] (const auto& events)
         {
             std::this_thread::sleep_for(std::chrono::seconds(1));
 
@@ -147,12 +147,12 @@ TEST(TransactionTest, LinkedSyncMerging)
     Group g1;
     Group g2;
 
-    EventSource<int> evt1( g1 );
+    auto evt1 = EventSource<int>::Create(g1);
 
     int output1 = 0;
     int turns1 = 0;
 
-    Observer obs1([&] (const auto& events)
+    auto obs1 = Observer::Create([&] (const auto& events)
         {
             ++turns1;
             for (int e : events)
@@ -164,7 +164,7 @@ TEST(TransactionTest, LinkedSyncMerging)
     int output2 = 0;
     int turns2 = 0;
 
-    Observer obs2([&] (const auto& events)
+    auto obs2 = Observer::Create([&] (const auto& events)
         {
             std::this_thread::sleep_for(std::chrono::seconds(1));
 

From 9fe1af70f4910216132f7aec109f11d92d8e6ef8 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:02:12 +0100
Subject: [PATCH 59/75] Commented out benchmarks for now.

---
 benchmarks/src/BenchmarkBase.h     |  2 +-
 benchmarks/src/BenchmarkFanout.h   |  8 ++++++--
 benchmarks/src/BenchmarkGrid.h     | 13 +++++++++++--
 benchmarks/src/BenchmarkRandom.h   | 11 +++++++----
 benchmarks/src/BenchmarkSequence.h |  8 ++++++--
 5 files changed, 31 insertions(+), 11 deletions(-)

diff --git a/benchmarks/src/BenchmarkBase.h b/benchmarks/src/BenchmarkBase.h
index d27d64b1..6684c062 100644
--- a/benchmarks/src/BenchmarkBase.h
+++ b/benchmarks/src/BenchmarkBase.h
@@ -14,7 +14,7 @@
 #include <fstream>
 #include <random>
 
-#include "react/common/Util.h"
+#include "react/common/utility.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Get unique random numbers from range.
diff --git a/benchmarks/src/BenchmarkFanout.h b/benchmarks/src/BenchmarkFanout.h
index a4855d0f..099f26d2 100644
--- a/benchmarks/src/BenchmarkFanout.h
+++ b/benchmarks/src/BenchmarkFanout.h
@@ -6,6 +6,8 @@
 
 #pragma once
 
+#if 0
+
 #ifndef CPP_REACT_BENCHMARK_FANOUT_H
 #define CPP_REACT_BENCHMARK_FANOUT_H
 
@@ -15,7 +17,7 @@
 
 #include "BenchmarkBase.h"
 
-#include "react/Signal.h"
+#include "react/state.h"
 /*
 using namespace react;
 
@@ -84,4 +86,6 @@ struct Benchmark_Fanout
 
 */
 
-#endif // CPP_REACT_BENCHMARK_FANOUT_H
\ No newline at end of file
+#endif // CPP_REACT_BENCHMARK_FANOUT_H
+
+#endif
\ No newline at end of file
diff --git a/benchmarks/src/BenchmarkGrid.h b/benchmarks/src/BenchmarkGrid.h
index 8f17d6f2..ad2d90af 100644
--- a/benchmarks/src/BenchmarkGrid.h
+++ b/benchmarks/src/BenchmarkGrid.h
@@ -6,6 +6,11 @@
 
 #pragma once
 
+#if 0
+
+#ifndef REACT_BENCHMARK_GRID_H
+#define REACT_BENCHMARK_GRID_H
+
 #include <functional>
 #include <iostream>
 #include <vector>
@@ -14,7 +19,7 @@
 
 #include "BenchmarkBase.h"
 
-#include "react/Signal.h"
+#include "react/state.h"
 
 using namespace react;
 
@@ -159,4 +164,8 @@ struct Benchmark_Grid
 
         return d;
     }
-};
\ No newline at end of file
+};
+
+#endif // REACT_BENCHMARK_GRID_H
+
+#endif
\ No newline at end of file
diff --git a/benchmarks/src/BenchmarkRandom.h b/benchmarks/src/BenchmarkRandom.h
index cec422da..80257410 100644
--- a/benchmarks/src/BenchmarkRandom.h
+++ b/benchmarks/src/BenchmarkRandom.h
@@ -6,16 +6,17 @@
 
 #pragma once
 
+#if 0
+
 #include <functional>
 #include <iostream>
 #include <random>
 #include <vector>
 
 #include "BenchmarkBase.h"
-#include "react/common/Types.h"
 
-#include "react/Group.h"
-#include "react/Signal.h"
+#include "react/group.h"
+#include "react/state.h"
 
 using namespace react;
 /*
@@ -320,4 +321,6 @@ struct Benchmark_Random
 
         return d;
     }
-};*/
\ No newline at end of file
+};*/
+
+#endif
\ No newline at end of file
diff --git a/benchmarks/src/BenchmarkSequence.h b/benchmarks/src/BenchmarkSequence.h
index 705e8f58..f02c4890 100644
--- a/benchmarks/src/BenchmarkSequence.h
+++ b/benchmarks/src/BenchmarkSequence.h
@@ -6,13 +6,15 @@
 
 #pragma once
 
+#if 0
+
 #include <iostream>
 #include <random>
 #include <vector>
 
 #include "BenchmarkBase.h"
 
-#include "react/Signal.h"
+#include "react/state.h"
 
 /*
 
@@ -77,4 +79,6 @@ struct Benchmark_Sequence
 
         return d;
     }
-};*/
\ No newline at end of file
+};*/
+
+#endif
\ No newline at end of file

From 35cea007cd3715eb97eccfed06d38808a7c9fd64 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:02:52 +0100
Subject: [PATCH 60/75] Fixed examples.

---
 benchmarks/src/Main.cpp               |  36 -----
 examples/src/BasicAlgorithms.cpp      | 197 +++++++++++++++-----------
 examples/src/BasicComposition.cpp     | 148 ++++++-------------
 examples/src/BasicEvents.cpp          |  75 ++++------
 examples/src/BasicObservers.cpp       |  53 ++-----
 examples/src/BasicSignals.cpp         |  83 +++++------
 examples/src/BasicSynchronization.cpp | 159 ++++++---------------
 7 files changed, 287 insertions(+), 464 deletions(-)

diff --git a/benchmarks/src/Main.cpp b/benchmarks/src/Main.cpp
index a191ccbc..d8bc4d76 100644
--- a/benchmarks/src/Main.cpp
+++ b/benchmarks/src/Main.cpp
@@ -4,7 +4,6 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-//#define REACT_ENABLE_LOGGING
 #if 0
 //#include "tbb/tick_count.h"
 //#include "tbb/tbbmalloc_proxy.h"
@@ -218,46 +217,11 @@ int main()
     //runBenchmarks();
     //debugBenchmarks();    
     //profileBenchmark();
-
-
 }
 
-struct Data
-{
-    State<int> a;
-    State<int> b;
-
-    State<Data*> (a, b);
-};
-
 #endif
 
-#include "react/common/expected.h"
-#include "react/state.h"
-#include "react/event.h"
-#include "react/algorithm.h"
-#include <iostream>
-
-#define unwind_on_error(x) if (!x) return UnwindExpected(std::move(x));
-
-using namespace react;
-
-
 int main()
 {
-    Group g;
-
-    VarSignal<int> t1(g);
-    VarSignal<int> t2(g);
-
-    EventSource<int> e1(g);
-    EventSource<int> e2(g);
-
-    auto h1 = Hold(1, e1);
-    auto h2 = Hold(2, e2);
-
-    auto m1 = Monitor(t1);
-    auto it1 = Iterate<int>(10, [] (EventRange<int> evnts, int b) { return b; }, e1);
-
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index 93235700..d6f8aced 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -9,10 +9,10 @@
 #include <utility>
 #include <vector>
 
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
-#include "react/Algorithm.h"
+#include "react/state.h"
+#include "react/event.h"
+#include "react/observer.h"
+#include "react/algorithm.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Converting events to signals
@@ -22,33 +22,35 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    Group group;
+    Group g;
 
     struct Sensor
     {
-        EventSource<int>   samples      { group };
-        Signal<int>        lastSample   = Hold(0, samples);
+        EventSource<int> samples    = EventSource<int>::Create(g);
+        State<int>       lastSample = Hold(0, samples);
+
+        auto GetReactiveMembers() const -> decltype(auto)
+            { return std::tie(lastSample); }
     };
 
     void Run()
     {
         cout << "Example 1 - Converting events to signals" << endl;
 
-        Sensor mySensor;
+        auto sensor = ObjectState<Sensor>::Create(g, Sensor{ });
 
-        Observer obs(
-            [] (int v)
+        auto obs = Observer::Create(g, [] (const auto& ctx)
             {
-                cout << v << endl;
-            },
-            mySensor.lastSample);
+                const Sensor& obj = ctx.GetObject();
+                cout << ctx.Get(obj.lastSample) << endl;
+            }, sensor);
 
-        mySensor.samples << 20 << 21 << 21 << 22; // output: 20, 21, 22
+        sensor->samples << 20 << 21 << 21 << 22; // output: 20, 21, 22
 
-        group.DoTransaction([&]
-        {
-            mySensor.samples << 30 << 31 << 31 << 32;
-        }); // output: 32
+        g.DoTransaction([&]
+            {
+                sensor->samples << 30 << 31 << 31 << 32;
+            }); // output: 32
 
         cout << endl;
     }
@@ -62,12 +64,12 @@ namespace example2
     using namespace std;
     using namespace react;
 
-    Group group;
+    Group g;
 
     struct Employee
     {
-        VarSignal<string>   name    { group, string( "Bob" ) };
-        VarSignal<int>      salary  { group, 3000 };
+        StateVar<string>   name    = StateVar<string>::Create(g, string( "Bob" ));
+        StateVar<int>      salary  = StateVar<int>::Create(g, 66666);
     };
 
     void Run()
@@ -76,13 +78,13 @@ namespace example2
 
         Employee bob;
 
-        Observer obs(
-            [] (EventRange<int> in, const string& name)
+        auto obs = Observer::Create([] (const auto& events, const string& name)
             {
-                for (int newSalary : in)
+                for (int newSalary : events)
                     cout << name << " now earns " << newSalary << endl;
-            },
-            Monitor(bob.salary), bob.name);
+            }, Monitor(bob.salary), bob.name);
+
+        bob.salary.Set(66667);
 
         cout << endl;
     }
@@ -96,21 +98,18 @@ namespace example3
     using namespace std;
     using namespace react;
 
-    Group group;
+    Group g;
 
     struct Counter
     {
-        EventSource<> increment { group };
+        EventSource<> increment = EventSource<>::Create(g);
 
-        Signal<int> count = Iterate<int>(
-            0,
-            [] (EventRange<> in, int count)
+        State<int> count = Iterate<int>(0, [] (const auto& events, int count)
             {
-                for (auto _ : in)
+                for (auto e : events)
                     ++count;
                 return count;
-            },
-            increment);
+            }, increment);
     };
 
     void Run()
@@ -123,7 +122,10 @@ namespace example3
         myCounter.increment.Emit();
         myCounter.increment.Emit();
 
-        cout << myCounter.count.Value() << endl; // output: 3
+        auto obs = Observer::Create([] (int v)
+            {
+                cout << v << endl; // output: 3
+            }, myCounter.count);
 
         cout << endl;
     }
@@ -137,33 +139,34 @@ namespace example4
     using namespace std;
     using namespace react;
 
-    Group group;
+    Group g;
 
     struct Sensor
     {
-        EventSource<float> input{ group };
+        EventSource<float> input = EventSource<float>::Create(g);
 
-        Signal<int> count = Iterate<int>(
-            0,
-            [] (EventRange<float> in, int count)
+        State<int> count = Iterate<int>(0, [] (const auto& events, int count)
             {
-                for (auto _ : in)
-                    count++;
+                for (auto e : events)
+                    ++count;
                 return count;
-            },
-            input);
+            }, input);
 
-        Signal<float> sum = Iterate<float>(
-            0.0f,
-            [] (EventRange<float> in, float sum)
+        State<float> sum = Iterate<float>(0.0f, [] (const auto& events, float sum)
             {
-                for (auto v : in)
-                    sum += v;
+                for (auto e : events)
+                    sum += e;
                 return sum;
-            },
-            input);
+            }, input);
 
-        VarSignal<float> average{ group };
+        State<float> average = State<float>::Create([] (int c, float s)
+            {
+                if (c != 0)
+                    return s / c;
+                else
+                    return 0.0f;
+                    
+            }, count, sum);
     };
 
     void Run()
@@ -174,7 +177,10 @@ namespace example4
 
         mySensor.input << 10.0f << 5.0f << 10.0f << 8.0f;
 
-        cout << "Average: " << mySensor.average.Value() << endl; // output: 8.25
+        auto obs = Observer::Create([] (float v)
+            {
+                cout << "Average: " << v << endl; // output: 8.25
+            }, mySensor.average);
 
         cout << endl;
     }
@@ -188,16 +194,16 @@ namespace example5
     using namespace std;
     using namespace react;
 
-    Group group;
+    Group g;
 
     enum ECmd { increment, decrement, reset };
 
     class Counter
     {
     private:
-        static int DoCounterLoop(EventRange<int> in, int count, int delta, int start)
+        static int DoCounterLoop(const EventValueList<int>& cmds, int count, int delta, int start)
         {
-            for (int cmd : in)
+            for (int cmd : cmds)
             {
                 if (cmd == increment)
                     count += delta;
@@ -211,12 +217,12 @@ namespace example5
         }
 
     public:
-        EventSource<int> update{ group };
+        EventSource<int> update = EventSource<int>::Create(g);
 
-        VarSignal<int> delta{ group, 1 };
-        VarSignal<int> start{ group, 0 };
+        StateVar<int> delta = StateVar<int>::Create(g, 1);
+        StateVar<int> start = StateVar<int>::Create(g, 0);
 
-        Signal<int> count{ Iterate<int>(start.Value(), DoCounterLoop, update, delta, start) };
+        State<int> count = Iterate<int>(0, DoCounterLoop, update, delta, start);
     };
 
     void Run()
@@ -225,23 +231,44 @@ namespace example5
 
         Counter myCounter;
 
-        cout << "Start: " << myCounter.count.Value() << endl; // output: 0
+        {
+            auto obs = Observer::Create([] (int v)
+                {
+                    cout << "Start: " << v << endl; // output: 0
+                }, myCounter.count);
+        }
+        
 
         myCounter.update.Emit(increment);
         myCounter.update.Emit(increment);
         myCounter.update.Emit(increment);
 
-        cout << "3x increment by 1: " << myCounter.count.Value() << endl; // output: 3
+        {
+            auto obs = Observer::Create([] (int v)
+                {
+                    cout << "3x increment by 1: " << v << endl; // output: 3
+                }, myCounter.count);
+        }
 
-        myCounter.delta <<= 5;
+        myCounter.delta.Set(5);
         myCounter.update.Emit(decrement);
 
-        cout << "1x decrement by 5: " << myCounter.count.Value() << endl; // output: -2
+        {
+            auto obs = Observer::Create([] (int v)
+                {
+                    cout << "1x decrement by 5: " << v << endl; // output: -2
+                }, myCounter.count);
+        }        
 
-        myCounter.start <<= 100;
+        myCounter.start.Set(100);
         myCounter.update.Emit(reset);
 
-        cout << "reset to 100: " << myCounter.count.Value() << endl; // output: 100
+        {
+            auto obs = Observer::Create([] (int v)
+                {
+                    cout << "reset to 100: " << v << endl; // output: 100
+                }, myCounter.count);
+        }
 
         cout << endl;
     }
@@ -255,32 +282,32 @@ namespace example6
     using namespace std;
     using namespace react;
 
-    Group group;
+    Group g;
 
     class Sensor
     {
     private:
-        static void DoIterateAllSamples(EventRange<int> in, vector<int>& all)
+        static void DoIterateAllSamples(const EventValueList<int>& events, vector<int>& all)
         {
-            for (int input : in)
+            for (int input : events)
                 all.push_back(input);
         }
 
-        static void DoIterateCritSamples(EventRange<int> in, vector<int>& critical, int threshold)
+        static void DoIterateCritSamples(const EventValueList<int> events, vector<int>& critical, int threshold)
         {
-            for (int input : in)
+            for (int input : events)
                 if (input > threshold)
                     critical.push_back(input);
         }
 
     public:
-        EventSource<int> input{ group };
+        EventSource<int> input = EventSource<int>::Create(g);
 
-        VarSignal<int> threshold{ group, 42 };
+        StateVar<int> threshold = StateVar<int>::Create(g, 42);
 
-        Signal<vector<int>> allSamples{ Iterate<vector<int>>(vector<int>{ }, DoIterateAllSamples, input) };
+        State<vector<int>> allSamples = IterateByRef<vector<int>>(vector<int>{ }, DoIterateAllSamples, input);
 
-        Signal<vector<int>> criticalSamples{ Iterate<vector<int>>(vector<int>{ }, DoIterateCritSamples, input, threshold) };
+        State<vector<int>> criticalSamples = IterateByRef<vector<int>>(vector<int>{ }, DoIterateCritSamples, input, threshold);
     };
 
     void Run()
@@ -292,15 +319,23 @@ namespace example6
         mySensor.input << 40 << 29 << 43 << 50;
 
         cout << "All samples: ";
-        for (auto const& v : mySensor.allSamples.Value())
-            cout << v << " ";
+        {
+            auto obs = Observer::Create([] (const auto& allSamples)
+                {
+                    for (auto const& v : allSamples)
+                        cout << v << " ";
+                }, mySensor.allSamples);
+        }
         cout << endl;
 
         cout << "Critical samples: ";
-        for (auto const& v : mySensor.criticalSamples.Value())
-            cout << v << " ";
-        cout << endl;
-
+        {
+            auto obs = Observer::Create([] (const auto& criticalSamples)
+                {
+                    for (auto const& v : criticalSamples)
+                        cout << v << " ";
+                }, mySensor.criticalSamples);
+        }
         cout << endl;
     }
 }
diff --git a/examples/src/BasicComposition.cpp b/examples/src/BasicComposition.cpp
index e2fbf3b1..acec053e 100644
--- a/examples/src/BasicComposition.cpp
+++ b/examples/src/BasicComposition.cpp
@@ -8,10 +8,9 @@
 #include <string>
 #include <utility>
 
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
+#include "react/state.h"
+#include "react/event.h"
+#include "react/observer.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Reactive class members
@@ -21,155 +20,99 @@ namespace example1
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    Group g;
 
     class Shape
     {
     public:
-        USING_REACTIVE_DOMAIN(D)
+        StateVar<int> width     = StateVar<int>::Create(g, 0);
+        StateVar<int> height    = StateVar<int>::Create(g, 0);
 
-        VarSignalT<int>     Width   = MakeVar<D>(0);
-        VarSignalT<int>     Height  = MakeVar<D>(0);
+        State<int> size         = State<int>::Create(g, CalcSize, width, height);
 
-        SignalT<int>        Size    = Width * Height;
+        auto GetReactiveMembers() const -> decltype(auto)
+            { return std::tie(width, height, size); }
 
-        EventSourceT<>      HasMoved = MakeEventSource<D>();
+    private:
+        static int CalcSize(int w, int h)
+            { return w * h; }
     };
 
     void Run()
     {
         cout << "Example 1 - Reactive class members" << endl;
 
-        Shape myShape;
+        auto myShape = ObjectState<Shape>::Create(g, Shape());
 
-        Observe(myShape.Size, [] (int newValue) {
-            cout << "Size changed to " << newValue << endl;
-        });
+        auto obs = Observer::Create([] (const auto& ctx)
+            {
+                const Shape& shape = ctx.GetObject();
+                cout << "Size is " << ctx.Get(shape.size) << endl;
+            }, myShape);
 
-        DoTransaction<D>([&] {
-            myShape.Width  <<= 4;
-            myShape.Height <<= 4; 
-        }); // output: Size changed to 16
+        g.DoTransaction([&]
+            {
+                myShape->width.Set(4);
+                myShape->height.Set(4);
+            }); // output: Size changed to 16
 
         cout << endl;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 2 - Signals of references
+/// Example 2 - Slots
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 namespace example2
 {
     using namespace std;
     using namespace react;
 
-    REACTIVE_DOMAIN(D, sequential)
+    Group g;
 
     class Company
     {
     public:
-        const char* Name;
+        StateVar<string> name;
 
         Company(const char* name) :
-            Name( name )
-        {}
+            name( StateVar<string>::Create(g, name) )
+        { }
 
-        // Note: To be used as a signal value type,
-        // values of the type must be comparable
         bool operator==(const Company& other) const
-        {
-            return this == &other;
-        }
+            { return name == other.name; }
     };
 
     class Employee
     {
     public:
-        USING_REACTIVE_DOMAIN(D)
+        StateSlot<string> myCompanyName;
 
-        VarSignalT<Company&> MyCompany;
+        Employee(const Company& company) :
+            myCompanyName( StateSlot<string>::Create(company.name) )
+        { }
 
-        Employee(Company& company) :
-            MyCompany( MakeVar<D>(ref(company)) )
-        {}
+        void SetCompany(const Company& company)
+            { myCompanyName.Set(company.name); }
     };
 
     void Run()
     {
-        cout << "Example 2 - Signals of references" << endl;
+        cout << "Example 2 - Slots" << endl;
 
-        Company     company1( "MetroTec" );
-        Company     company2( "ACME" );
-
-        Employee    bob( company1 );
-
-        Observe(bob.MyCompany, [] (const Company& company) {
-            cout << "Bob works for " << company.Name << endl;
-        });
-
-        bob.MyCompany <<= ref(company2); // output: Bob now works for ACME
-
-        cout << endl;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 3 - Dynamic signal references
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace example3
-{
-    using namespace std;
-    using namespace react;
-
-    REACTIVE_DOMAIN(D, sequential)
-
-    class Company
-    {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        VarSignalT<string> Name;
-
-        Company(const char* name) :
-            Name( MakeVar<D>(string( name )) )
-        {}
-
-        bool operator==(const Company& other) const
-        {
-            return this == &other;
-        }
-    };
-
-    class Employee
-    {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        VarSignalT<Company&> MyCompany;
-
-        Employee(Company& company) :
-            MyCompany( MakeVar<D>(ref(company)) )
-        {}
-    };
-
-    void Run()
-    {
-        cout << "Example 3 - Dynamic signal references" << endl;
-
-        Company     company1( "MetroTec" );
-        Company     company2( "ACME" );
+        Company company1( "MetroTec" );
+        Company company2( "ACME" );
 
         Employee    alice( company1 );
 
-        auto obs = Observe(
-            REACTIVE_REF(alice.MyCompany, Name),
-            [] (const string& name) {
+        auto obs = Observer::Create([] (const string& name)
+            {
                 cout << "Alice now works for " << name << endl;
-            });
+            }, alice.myCompanyName);
 
-        company1.Name   <<= string( "ModernTec" );  // output: Alice now works for ModernTec
-        alice.MyCompany <<= ref(company2);          // output: Alice now works for ACME
-        company2.Name   <<= string( "A.C.M.E." );   // output: Alice now works for A.C.M.E.
+        company1.name.Set(string( "ModernTec" ));   // output: Alice now works for ModernTec
+        alice.SetCompany(company2);                 // output: Alice now works for ACME
+        company2.name.Set(string( "A.C.M.E." ));    // output: Alice now works for A.C.M.E.
 
         cout << endl;
     }
@@ -181,10 +124,7 @@ namespace example3
 int main()
 {
     example1::Run();
-
     example2::Run();
 
-    example3::Run();
-
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicEvents.cpp b/examples/src/BasicEvents.cpp
index 53e97984..98fe1ef3 100644
--- a/examples/src/BasicEvents.cpp
+++ b/examples/src/BasicEvents.cpp
@@ -27,19 +27,17 @@ namespace example1
     // An event source that emits values of type string
     namespace v1
     {
-        EventSource<string> mySource( group );
+        EventSource<string> mySource = EventSource<string>::Create(group);
 
         void Run()
         {
             cout << "Example 1 - Hello world (string source)" << endl;
 
-            Observer obs(
-                [] (EventRange<string> in)
+            auto obs = Observer::Create([] (const auto& events)
                 {
-                    for (const auto& s : in)
-                        cout << s << std::endl;
-                },
-                mySource);
+                    for (const auto& e : events)
+                        cout << e << std::endl;
+                }, mySource);
 
             mySource << string("Hello world #1");
 
@@ -53,7 +51,7 @@ namespace example1
     // An event source without an explicit value type
     namespace v2
     {
-        EventSource<> helloWorldTrigger( group );
+        EventSource<> helloWorldTrigger = EventSource<>::Create(group);
 
         void Run()
         {
@@ -61,13 +59,11 @@ namespace example1
 
             int count = 0;
 
-            Observer obs(
-                [&] (EventRange<> in)
+            auto obs = Observer::Create([&] (const auto& events)
                 {
-                    for (auto t : in)
+                    for (auto t : events)
                         cout << "Hello world #" << ++count << endl;
-                },
-                helloWorldTrigger);
+                }, helloWorldTrigger);
 
             helloWorldTrigger.Emit();
 
@@ -90,8 +86,8 @@ namespace example2
     Group group;
 
     // An event stream that merges both sources
-    EventSource<> leftClick( group );
-    EventSource<> rightClick( group );
+    EventSource<> leftClick = EventSource<>::Create(group);
+    EventSource<> rightClick = EventSource<>::Create(group);
 
     Event<> anyClick = Merge(leftClick, rightClick);
 
@@ -101,13 +97,11 @@ namespace example2
 
         int count = 0;
 
-        Observer obs(
-            [&] (EventRange<> in)
+        auto obs = Observer::Create([&] (const auto& events)
             {
-                for (auto t : in)
+                for (auto t : events)
                     cout << "clicked #" << ++count << endl;
-            },
-            anyClick);
+            }, anyClick);
 
         leftClick.Emit();  // output: clicked #1 
         rightClick.Emit(); // output: clicked #2
@@ -126,7 +120,7 @@ namespace example3
 
     Group group;
 
-    EventSource<int> numbers( group );
+    EventSource<int> numbers = EventSource<int>::Create(group);
 
     Event<int> greater10 = Filter([] (int n) { return n > 10; }, numbers);
 
@@ -134,13 +128,11 @@ namespace example3
     {
         cout << "Example 3 - Filtering events" << endl;
 
-        Observer obs(
-            [&] (EventRange<int> in)
+        auto obs = Observer::Create([&] (const auto& events)
             {
-                for (auto n : in)
+                for (auto n : events)
                     cout << n << endl;
-            },
-            greater10);
+            }, greater10);
 
         numbers << 5 << 11 << 7 << 100; // output: 11, 100
 
@@ -162,34 +154,30 @@ namespace example4
     enum class Tag { normal, critical };
     using TaggedNum = pair<Tag, int>;
 
-    EventSource<int> numbers( group );
+    EventSource<int> numbers = EventSource<int>::Create(group);
 
-    Event<TaggedNum> tagged = Transform<TaggedNum>(
-        [] (int n)
+    Event<TaggedNum> tagged = Transform<TaggedNum>([] (int n)
         {
             if (n > 10)
                 return TaggedNum( Tag::critical, n );
             else
                 return TaggedNum( Tag::normal, n );
-        },
-        numbers);
+        }, numbers);
 
     void Run()
     {
         cout << "Example 4 - Transforming  events" << endl;
 
-        Observer obs(
-            [] (EventRange<TaggedNum> in)
+        auto obs = Observer::Create([] (const auto& events)
             {
-                for (TaggedNum e : in)
+                for (TaggedNum e : events)
                 {
                     if (e.first == Tag::critical)
                         cout << "(critical) " << e.second << endl;
                     else
                         cout << "(normal)  " << e.second << endl;
                 }
-            },
-            tagged);
+            }, tagged);
 
         numbers << 5;   // output: (normal) 5
         numbers << 20;  // output: (critical) 20
@@ -208,25 +196,24 @@ namespace example5
 
     Group group;
 
-    EventSource<int> src( group );
+    EventSource<int> src = EventSource<int>::Create(group);
 
     void Run()
     {
         cout << "Example 5 - Queuing multiple inputs" << endl;
 
-        Observer obs(
-            [] (EventRange<int> in)
+        auto obs = Observer::Create([] (const auto& events)
             {
-                for (int e : in)
+                for (int e : events)
                     cout << e << endl;
             }, src);
         // output: 1, 2, 3, 4
 
         group.DoTransaction([]
-        {
-            src << 1 << 2 << 3;
-            src << 4;
-        });
+            {
+                src << 1 << 2 << 3;
+                src << 4;
+            });
 
         cout << endl;
     }
diff --git a/examples/src/BasicObservers.cpp b/examples/src/BasicObservers.cpp
index 8eb03b81..54b24857 100644
--- a/examples/src/BasicObservers.cpp
+++ b/examples/src/BasicObservers.cpp
@@ -8,9 +8,9 @@
 #include <string>
 #include <utility>
 
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
+#include "react/state.h"
+#include "react/event.h"
+#include "react/observer.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Creating subject-bound observers
@@ -22,55 +22,21 @@ namespace example1
 
     Group group;
 
-    VarSignal<int> x( group, 1 );
+    StateVar<int> x = StateVar<int>::Create(group, 1);
 
     void Run()
     {
-        cout << "Example 1 - Creating subject-bound observers (v1)" << endl;
+        cout << "Example 1 - Creating observers" << endl;
 
         {
-            Signal<int> mySignal( [] (int x) { return x; }, x );
+            auto st = State<int>::Create([] (int x) { return x; }, x);
 
-            Observer obs( [] (int mySignal) { cout << mySignal << endl; }, mySignal );
+            auto obs = Observer::Create([] (int v) { cout << v << endl; }, st);
 
-            x <<= 2; // output: 2
+            x.Set(2); // output: 2
         }
 
-        x <<= 3; // no ouput
-
-        cout << endl;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 2 - Detaching observers manually
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace example2
-{
-    using namespace std;
-    using namespace react;
-
-    Group group;
-
-    EventSource<> trigger( group );
-
-    void Run()
-    {
-        cout << "Example 2 - Detaching observers manually" << endl;
-
-        {
-            Observer obs(
-                [] (EventRange<> in)
-                {
-                    for (auto _ : in)
-                        cout << "Triggered!" << endl;
-                },
-                trigger);
-
-            trigger.Emit(); // output: Triggered!
-        }
-
-        trigger.Emit(); // no output
+        x.Set(3); // no ouput
 
         cout << endl;
     }
@@ -82,7 +48,6 @@ namespace example2
 int main()
 {
     example1::Run();
-    example2::Run();
 
     return 0;
 }
\ No newline at end of file
diff --git a/examples/src/BasicSignals.cpp b/examples/src/BasicSignals.cpp
index 749116c8..c743de83 100644
--- a/examples/src/BasicSignals.cpp
+++ b/examples/src/BasicSignals.cpp
@@ -11,8 +11,8 @@
 #include <utility>
 #include <vector>
 
-#include "react/Signal.h"
-#include "react/Observer.h"
+#include "react/state.h"
+#include "react/observer.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Hello world
@@ -35,21 +35,20 @@ namespace example1
     Group group;
     
     // The two words
-    VarSignal<string> firstWord( group, string("Change") );
-    VarSignal<string> secondWord( group, string("me!") );
+    StateVar<string> firstWord = StateVar<string>::Create(group, string("Change"));
+    StateVar<string> secondWord = StateVar<string>::Create(group, string("me!"));
 
     // A signal that concatenates both words
-    Signal<string> bothWords(ConcatFunc, firstWord, secondWord);
+    State<string> bothWords = State<string>::Create(ConcatFunc, firstWord, secondWord);
 
     void Run()
     {
-        Observer obs{ PrintFunc, bothWords };
+        auto obs = Observer::Create(PrintFunc, bothWords);
 
         cout << "Example 1 - Hello world" << endl;
 
-        firstWord <<= string("Hello");
-
-        secondWord <<= string("World");
+        firstWord.Set(string("Hello"));
+        secondWord.Set(string("World"));
 
         cout << endl;
     }
@@ -65,22 +64,21 @@ namespace example2
 
     Group group;
 
-    VarSignal<int> x( group, 1 );
+    StateVar<int> x = StateVar<int>::Create(group, 1);
 
-    Signal<int> xAbs( [] (int v) { return abs(v); }, x);
+    State<int> xAbs = State<int>::Create([] (int v) { return abs(v); }, x);
 
     void Run()
     {
         cout << "Example 2 - Reacting to value changes" << endl;
 
-        Observer obs(
-            [] (int newValue) { cout << "xAbs changed to " << newValue << endl; },
-            xAbs );
+        auto obs = Observer::Create([] (int newValue)
+            { cout << "xAbs changed to " << newValue << endl; }, xAbs);
 
                     // initially x is 1
-        x <<=  2;   // output: xAbs changed to 2
-        x <<= -3;   // output: xAbs changed to 3
-        x <<=  3;   // no output, xAbs is still 3
+        x.Set(2);   // output: xAbs changed to 2
+        x.Set(-3);  // output: xAbs changed to 3
+        x.Set(3);   // no output, xAbs is still 3
 
         cout << endl;
     }
@@ -99,29 +97,28 @@ namespace example3
 
     Group group;
 
-    VarSignal<int> a( group, 1 );
-    VarSignal<int> b( group, 1 );
+    StateVar<int> a = StateVar<int>::Create(group, 1);
+    StateVar<int> b = StateVar<int>::Create(group, 1);
 
-    Signal<int> x( sumFunc, a, b );
-    Signal<int> y( sumFunc, a, b );
-    Signal<int> z( sumFunc, x, y );
+    State<int> x = State<int>::Create(sumFunc, a, b);
+    State<int> y = State<int>::Create(sumFunc, a, b);
+    State<int> z = State<int>::Create(sumFunc, x, y);
 
     void Run()
     {
         cout << "Example 3 - Changing multiple inputs" << endl;
 
-        Observer obs(
-            [] (int newValue) { cout << "z changed to " << newValue << endl; },
-            z );
+        auto obs = Observer::Create([] (int newValue)
+            { cout << "z changed to " << newValue << endl; }, z);
 
-        a <<= 2; // output: z changed to 6
-        b <<= 2; // output: z changed to 8
+        a.Set(2); // output: z changed to 6
+        b.Set(2); // output: z changed to 8
 
         group.DoTransaction([&]
-        {
-            a <<= 4;
-            b <<= 4; 
-        }); // output: z changed to 16
+            {
+                a.Set(4);
+                b.Set(4); 
+            }); // output: z changed to 16
 
         cout << endl;
     }
@@ -137,7 +134,7 @@ namespace example4
 
     Group group;
 
-    VarSignal<vector<string>> data( group );
+    StateVar<vector<string>> data = StateVar<vector<string>>::Create(group);
 
     void Run()
     {
@@ -149,8 +146,13 @@ namespace example4
         data.Modify([] (vector<string>& data)
             { data.push_back("World"); });
 
-//        for (const auto& s : data.Value())
-//            cout << s << " ";
+        auto obs = Observer::Create([] (const vector<string>& data)
+            {
+                for (const auto& s : data)
+                    cout << s << " ";
+            }, data);
+
+
         cout << endl;
         // output: Hello World
 
@@ -185,12 +187,11 @@ namespace example5
     }
 
     // Input operands
-    VarSignal<int> a( group, 1 );
-    VarSignal<int> b( group, 2 );
+    StateVar<int> a = StateVar<int>::Create(group, 1);
+    StateVar<int> b = StateVar<int>::Create(group, 2);
 
     // The expression vector
-    Signal<ExprVectType> expressions(
-        [] (int a, int b)
+    State<ExprVectType> expressions = State<ExprVectType>::Create([] (int a, int b)
         {
             ExprVectType result;
             result.push_back(make_pair(MakeExprStr(a, b, "+"), a + b));
@@ -203,10 +204,10 @@ namespace example5
     {
         cout << "Example 5 - Complex signals (v3)" << endl;
 
-        Observer obs(PrintExpressions, expressions);
+        auto obs = Observer::Create(PrintExpressions, expressions);
 
-        a <<= 50;
-        b <<= 60;
+        a.Set(50);
+        b.Set(60);
 
         cout << endl;
     }
diff --git a/examples/src/BasicSynchronization.cpp b/examples/src/BasicSynchronization.cpp
index 701b5001..d5b29de7 100644
--- a/examples/src/BasicSynchronization.cpp
+++ b/examples/src/BasicSynchronization.cpp
@@ -8,10 +8,9 @@
 
 #include "tbb/tick_count.h"
 
-#include "react/Domain.h"
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Observer.h"
+#include "react/state.h"
+#include "react/event.h"
+#include "react/observer.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Example 1 - Asynchronous transactions
@@ -21,50 +20,41 @@ namespace example1
     using namespace react;
     using namespace std;
 
-    Group<> group;
+    Group group;
 
     class Sensor
     {
     public:
-        Sensor(const Sensor&) = default;
-        Sensor& operator=(const Sensor&) = default;
-        Sensor(Sensor&&) = default;
-        Sensor& operator=(Sensor&&) = default;
-
-        explicit Sensor(const Group<>& group) :
-            Samples( group )
-            { }
-
-        EventSource<int>    Samples;
+        EventSource<int> samples = EventSource<int>::Create(group);
     };
 
     void Run()
     {
         cout << "Example 1 - Asynchronous transactions" << endl;
 
-        Sensor mySensor( group );
+        Sensor mySensor;
 
-        Observer<> obs(
-            [&] (EventRange<> in)
+        auto obs = Observer::Create([&] (const auto& events)
             {
-                for (auto t : in)
-                    cout << v << endl;
-            },
-            mySensor.Samples);
+                for (auto t : events)
+                    cout << t << endl;
+            }, mySensor.samples);
 
-        TransactionStatus status;
+        SyncPoint sp;
 
-        AsyncTransaction<D>(status, [&] {
-            mySensor.Samples << 30 << 31 << 31 << 32;
-        });
+        group.EnqueueTransaction([&]
+            {
+                mySensor.samples << 30 << 31 << 31 << 32;
+            }, sp);
 
-        AsyncTransaction<D>(status, [&] {
-            mySensor.Samples << 40 << 41 << 51 << 62;
-        });
+        group.EnqueueTransaction([&]
+            {
+                mySensor.samples << 40 << 41 << 51 << 62;
+            }, sp);
 
         // Waits until both transactions are completed.
         // This does not mean that both transactions are interleaved.
-        status.Wait();
+        sp.Wait();
 
         cout << endl;
     }
@@ -78,17 +68,15 @@ namespace example2
     using namespace react;
     using namespace std;
 
-    REACTIVE_DOMAIN(D, sequential_concurrent)
+    Group group;
 
     class Sensor
     {
     public:
-        USING_REACTIVE_DOMAIN(D)
-
-        EventSourceT<int>   Samples     = MakeEventSource<D,int>();
+        EventSource<int> samples = EventSource<int>::Create(group);
     };
 
-    const int K = 100000;
+    const int K = 10000;
 
     namespace v1
     {
@@ -99,11 +87,13 @@ namespace example2
             Sensor mySensor;
             int sum = 0;
 
-            Observe(mySensor.Samples, [&] (int v) {
-                sum += v;
-            });
+            auto obs = Observer::Create([&] (const auto& events)
+                {
+                    for (int e : events)
+                        sum += e;
+                }, mySensor.samples);
 
-            TransactionStatus status;
+            SyncPoint sp;
 
             cout << "Executing " << K << " async transactions...";
 
@@ -111,12 +101,13 @@ namespace example2
 
             for (int i=0; i < K; i++)
             {
-                AsyncTransaction<D>(status, [&] {
-                    mySensor.Samples << 3 << 4 << 2 << 1;
-                });
+                group.EnqueueTransaction([&]
+                    {
+                        mySensor.samples << 3 << 4 << 2 << 1;
+                    }, sp);
             }
 
-            status.Wait();
+            sp.Wait();
 
             double d = (tbb::tick_count::now() - t0).seconds();
 
@@ -138,11 +129,13 @@ namespace example2
             Sensor mySensor;
             int sum = 0;
 
-            Observe(mySensor.Samples, [&] (int v) {
-                sum += v;
-            });
+            auto obs = Observer::Create([&] (const auto& events)
+                {
+                    for (int e : events)
+                        sum += e;
+                }, mySensor.samples);
 
-            TransactionStatus status;
+            SyncPoint sp;
 
             cout << "Executing " << K << " async transactions...";
 
@@ -150,12 +143,13 @@ namespace example2
 
             for (int i=0; i < K; i++)
             {
-                AsyncTransaction<D>(allow_merging, status, [&] {
-                    mySensor.Samples << 3 << 4 << 2 << 1;
-                });
+                group.EnqueueTransaction([&]
+                    {
+                        mySensor.samples << 3 << 4 << 2 << 1;
+                    }, sp, TransactionFlags::allow_merging);
             }
 
-            status.Wait();
+            sp.Wait();
 
             double d = (tbb::tick_count::now() - t0).seconds();
 
@@ -169,67 +163,6 @@ namespace example2
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Example 3 - Continuations (1)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace example3
-{
-    using namespace react;
-    using namespace std;
-
-    REACTIVE_DOMAIN(D, sequential_concurrent)
-
-    class Widget
-    {
-    public:
-        USING_REACTIVE_DOMAIN(D)
-
-        VarSignalT<string>  Label1 = MakeVar<D>(string( "Change" ));
-        VarSignalT<string>  Label2 = MakeVar<D>(string( "me!" ));
-
-        EventSourceT<>      Reset  = MakeEventSource<D>();
-
-        Widget() :
-            resetCont_
-            (
-                MakeContinuation<D>(
-                    Reset,
-                    [this] (Token) {
-                        Label1 <<= string( "Change" );
-                        Label2 <<= string( "me!" );
-                    })
-            )
-        {}
-
-    private:
-        Continuation<D> resetCont_;
-    };
-
-    void Run()
-    {
-        cout << "Example 3 - Continuations (1)" << endl;
-
-        Widget myWidget;
-
-        Observe(myWidget.Label1, [&] (const string& v) {
-            cout << "Label 1 changed to " << v << endl;
-        });
-
-        Observe(myWidget.Label2, [&] (const string& v) {
-            cout << "Label 2 changed to " << v << endl;
-        });
-
-        myWidget.Label1 <<= "Hello";
-        myWidget.Label2 <<= "world";
-
-        cout << "Resetting..." << endl;
-
-        myWidget.Reset();
-
-        cout << endl;
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Run examples
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -240,7 +173,5 @@ int main()
     example2::v1::Run();
     example2::v2::Run();
 
-    example3::Run();
-
     return 0;
 }
\ No newline at end of file

From 6a936621281532a914c75b1886da54f56d1d9832 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:03:57 +0100
Subject: [PATCH 61/75] Fixes + cleanup.

---
 include/react/detail/graph_impl.h     | 26 ++++++++++++++++++++++
 include/react/detail/observer_nodes.h |  2 +-
 include/react/detail/state_nodes.h    | 12 ++++++----
 include/react/group.h                 | 32 ---------------------------
 include/react/state.h                 | 19 ++++++++++++----
 project/msvc/CppReact.sln             | 11 ---------
 project/msvc/CppReact.vcxproj         |  3 ---
 project/msvc/CppReact.vcxproj.filters | 12 ----------
 tests/src/state_tests.cpp             |  4 ++--
 9 files changed, 52 insertions(+), 69 deletions(-)

diff --git a/include/react/detail/graph_impl.h b/include/react/detail/graph_impl.h
index 42c04789..14391d14 100644
--- a/include/react/detail/graph_impl.h
+++ b/include/react/detail/graph_impl.h
@@ -216,6 +216,32 @@ void ReactGraph::EnqueueTransaction(F&& func, SyncPoint::Dependency dep, Transac
     transactionQueue_.Push(std::forward<F>(func), std::move(dep), flags);
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// GroupInternals
+///////////////////////////////////////////////////////////////////////////////////////////////////
+class GroupInternals
+{
+public:
+    GroupInternals() :
+        graphPtr_( std::make_shared<ReactGraph>() )
+    {  }
+
+    GroupInternals(const GroupInternals&) = default;
+    GroupInternals& operator=(const GroupInternals&) = default;
+
+    GroupInternals(GroupInternals&&) = default;
+    GroupInternals& operator=(GroupInternals&&) = default;
+
+    auto GetGraphPtr() -> std::shared_ptr<ReactGraph>&
+        { return graphPtr_; }
+
+    auto GetGraphPtr() const -> const std::shared_ptr<ReactGraph>&
+        { return graphPtr_; }
+
+private:
+    std::shared_ptr<ReactGraph> graphPtr_;
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_PROPAGATION_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/observer_nodes.h b/include/react/detail/observer_nodes.h
index 9634c89c..dd051384 100644
--- a/include/react/detail/observer_nodes.h
+++ b/include/react/detail/observer_nodes.h
@@ -150,7 +150,7 @@ class SyncedEventObserverNode : public ObserverNode
             return UpdateResult::unchanged;
 
         apply([this] (const auto& ... syncs)
-            { func_(EventRange<E>( GetInternals(this->subject_).Events() ), GetInternals(syncs).Value() ...); }, syncHolder_);
+            { func_(GetInternals(this->subject_).Events(), GetInternals(syncs).Value() ...); }, syncHolder_);
 
         return UpdateResult::unchanged;
     }
diff --git a/include/react/detail/state_nodes.h b/include/react/detail/state_nodes.h
index ea78c20b..aa8c8b85 100644
--- a/include/react/detail/state_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -346,7 +346,8 @@ class ObjectStateNode : public StateNode<ObjectContext<S>>
 {
 public:
     ObjectStateNode(const Group& group, S&& obj, const std::initializer_list<NodeId>& memberIds) :
-        ObjectStateNode::StateNode( group, std::move(obj) )
+        ObjectStateNode::StateNode( group, &object_ ),
+        object_( std::move(obj) )
     {
         this->RegisterMe();
 
@@ -356,7 +357,7 @@ class ObjectStateNode : public StateNode<ObjectContext<S>>
                 {
                     REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId()));
                     REACT_EXPAND_PACK(this->AttachToMe(GetInternals(members).GetNodeId()));
-                }, this->Value().GetObject().GetReactiveMembers());
+                }, object_.GetReactiveMembers());
         }
         else
         {
@@ -372,16 +373,18 @@ class ObjectStateNode : public StateNode<ObjectContext<S>>
 
     template <typename ... Us>
     ObjectStateNode(InPlaceTag, const Group& group, Us&& ... args) :
-        ObjectStateNode::StateNode( in_place, group, group, std::forward<Us>(args) ... )
+        ObjectStateNode::StateNode( group, &object_ ),
+        object_( group, std::forward<Us>(args) ... )
     {
         this->RegisterMe();
 
         apply([this] (const auto& ... members)
-            { REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId())); }, this->Value().GetObject().GetReactiveMembers());
+            { REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId())); }, object_.GetReactiveMembers());
     }
 
     ~ObjectStateNode()
     {
+        // TODO: This must happen inside of the node
         for (NodeId id : memberIds_)
             this->DetachFromMe(id);
 
@@ -394,6 +397,7 @@ class ObjectStateNode : public StateNode<ObjectContext<S>>
     }
 
 private:
+    S object_;
     std::vector<NodeId> memberIds_;
 };
 
diff --git a/include/react/group.h b/include/react/group.h
index 45ec476a..d534d7e4 100644
--- a/include/react/group.h
+++ b/include/react/group.h
@@ -20,38 +20,6 @@
 #include "react/detail/graph_interface.h"
 #include "react/detail/graph_impl.h"
 
-/***************************************/ REACT_IMPL_BEGIN /**************************************/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// GroupInternals
-///////////////////////////////////////////////////////////////////////////////////////////////////
-class GroupInternals
-{
-    using GraphType = REACT_IMPL::ReactGraph;
-
-public:
-    GroupInternals() :
-        graphPtr_( std::make_shared<GraphType>() )
-        {  }
-
-    GroupInternals(const GroupInternals&) = default;
-    GroupInternals& operator=(const GroupInternals&) = default;
-
-    GroupInternals(GroupInternals&&) = default;
-    GroupInternals& operator=(GroupInternals&&) = default;
-
-    auto GetGraphPtr() -> std::shared_ptr<GraphType>&
-        { return graphPtr_; }
-
-    auto GetGraphPtr() const -> const std::shared_ptr<GraphType>&
-        { return graphPtr_; }
-
-private:
-    std::shared_ptr<GraphType> graphPtr_;
-};
-
-/****************************************/ REACT_IMPL_END /***************************************/
-
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/state.h b/include/react/state.h
index 6c93de6c..d8235d37 100644
--- a/include/react/state.h
+++ b/include/react/state.h
@@ -39,6 +39,11 @@ class State : protected REACT_IMPL::StateInternals<S>
     static State Create(F&& func, const State<T1>& dep1, const State<Ts>& ... deps)
         { return CreateFuncNode(dep1.GetGroup(), std::forward<F>(func), dep1, deps ...); }
 
+    // Construct with constant value
+    template <typename T>
+    static State Create(const Group& group, T&& init)
+        { return CreateFuncNode(group, [value = std::move(init)] { return value; }); }
+
     State() = default;
 
     State(const State&) = default;
@@ -292,8 +297,11 @@ class ObjectContext
     ObjectContext(ObjectContext&&) = default;
     ObjectContext& operator=(ObjectContext&&) = default;
 
+    S& GetObject()
+        { return *objectPtr_; }
+
     const S& GetObject() const
-        { return object_; }
+        { return *objectPtr_; }
 
     template <typename U>
     const U& Get(const State<U>& member) const
@@ -305,11 +313,11 @@ class ObjectContext
 
 private:
     template <typename ... Us>
-    explicit ObjectContext(Us&& ... args) :
-        object_( std::forward<Us>(args) ... )
+    explicit ObjectContext(S* objectPtr) :
+        objectPtr_( objectPtr )
     { }
 
-    S object_;
+    S* objectPtr_;
 
     template <typename U>
     friend class impl::StateNode;
@@ -345,6 +353,9 @@ class ObjectState : public State<ObjectContext<S>>
     ObjectState(ObjectState&&) = default;
     ObjectState& operator=(ObjectState&&) = default;
 
+    S* operator->()
+        { return &this->Value().GetObject(); }
+
 protected:
     ObjectState(std::shared_ptr<REACT_IMPL::StateNode<ObjectContext<S>>>&& nodePtr) :
         ObjectState::State( std::move(nodePtr) )
diff --git a/project/msvc/CppReact.sln b/project/msvc/CppReact.sln
index 5f987e52..6d60b1c9 100644
--- a/project/msvc/CppReact.sln
+++ b/project/msvc/CppReact.sln
@@ -17,8 +17,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "4_Benchmarks", "4_Benchmark
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "2_Tests", "2_Tests", "{3F97AA87-0A03-4428-94C1-C9B4007C2C80}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CppReactExample", "CppReactExample.vcxproj", "{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicAlgorithms", "Example_BasicAlgorithms.vcxproj", "{617019A2-97BE-4A60-8EC4-3547D8C54533}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example_BasicComposition", "Example_BasicComposition.vcxproj", "{D7B70D3B-F14D-4A85-B164-EAB88C358E85}"
@@ -67,14 +65,6 @@ Global
 		{52A9EC67-C6A7-453B-AD65-F027CA07AF44}.Release|Win32.Build.0 = Release|Win32
 		{52A9EC67-C6A7-453B-AD65-F027CA07AF44}.Release|x64.ActiveCfg = Release|x64
 		{52A9EC67-C6A7-453B-AD65-F027CA07AF44}.Release|x64.Build.0 = Release|x64
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Debug|Win32.ActiveCfg = Debug|Win32
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Debug|Win32.Build.0 = Debug|Win32
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Debug|x64.ActiveCfg = Debug|x64
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Debug|x64.Build.0 = Debug|x64
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Release|Win32.ActiveCfg = Release|Win32
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Release|Win32.Build.0 = Release|Win32
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Release|x64.ActiveCfg = Release|x64
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB}.Release|x64.Build.0 = Release|x64
 		{617019A2-97BE-4A60-8EC4-3547D8C54533}.Debug|Win32.ActiveCfg = Debug|Win32
 		{617019A2-97BE-4A60-8EC4-3547D8C54533}.Debug|Win32.Build.0 = Debug|Win32
 		{617019A2-97BE-4A60-8EC4-3547D8C54533}.Debug|x64.ActiveCfg = Debug|x64
@@ -151,7 +141,6 @@ Global
 		{5E56AAB9-4E33-4B9E-A315-E85CEDB75CF1} = {91AFD614-F7E6-48CE-9808-642EAF476B66}
 		{F9115FB9-61DD-4B3C-BCE8-7D26372B05F7} = {D6F88FF5-E55C-4E65-ABBB-B4298AB84D40}
 		{52A9EC67-C6A7-453B-AD65-F027CA07AF44} = {3F97AA87-0A03-4428-94C1-C9B4007C2C80}
-		{CC0CD982-AE7D-4797-A122-58E6BBE70DDB} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{617019A2-97BE-4A60-8EC4-3547D8C54533} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{D7B70D3B-F14D-4A85-B164-EAB88C358E85} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
 		{BD777649-97F1-4810-BF21-CB27F7672BF4} = {518ACABC-E4A7-4E2D-9A04-FFA669A30DBF}
diff --git a/project/msvc/CppReact.vcxproj b/project/msvc/CppReact.vcxproj
index 088c482f..47748a0d 100644
--- a/project/msvc/CppReact.vcxproj
+++ b/project/msvc/CppReact.vcxproj
@@ -177,9 +177,6 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\src\detail\graph_impl.cpp" />
-    <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp" />
-    <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp" />
-    <ClCompile Include="..\..\src\engine\ToposortEngine.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
diff --git a/project/msvc/CppReact.vcxproj.filters b/project/msvc/CppReact.vcxproj.filters
index 040e8acc..5652b8e2 100644
--- a/project/msvc/CppReact.vcxproj.filters
+++ b/project/msvc/CppReact.vcxproj.filters
@@ -19,9 +19,6 @@
     <Filter Include="Header Files\common">
       <UniqueIdentifier>{11a75126-8bfd-4693-be4b-4e06ab73450c}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\engine">
-      <UniqueIdentifier>{3f444875-ab1a-4bbd-99eb-7018c930098a}</UniqueIdentifier>
-    </Filter>
     <Filter Include="Source Files\detail">
       <UniqueIdentifier>{45678bfc-0ce5-4e47-a365-54a72d8ecb6d}</UniqueIdentifier>
     </Filter>
@@ -83,15 +80,6 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\src\engine\SubtreeEngine.cpp">
-      <Filter>Source Files\engine</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\src\engine\ToposortEngine.cpp">
-      <Filter>Source Files\engine</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\src\engine\PulsecountEngine.cpp">
-      <Filter>Source Files\engine</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\src\detail\graph_impl.cpp">
       <Filter>Source Files\detail</Filter>
     </ClCompile>
diff --git a/tests/src/state_tests.cpp b/tests/src/state_tests.cpp
index 10e41205..ab9d70b8 100644
--- a/tests/src/state_tests.cpp
+++ b/tests/src/state_tests.cpp
@@ -475,6 +475,6 @@ TEST(StateTest, Object)
             int height = ctx.Get(widget.height);
         }, st1);
 
-    w1.color.Set(10);
-    w2.color.Set(20);
+    st1->color.Set(10);
+    st2->color.Set(20);
 }
\ No newline at end of file

From 40ea6e424d2fcd37abb4946a015e79de9a6ebf2a Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:06:00 +0100
Subject: [PATCH 62/75] Removed react player. No longer supported with new
 codebase.

---
 tools/ReactPlayer/ReactPlayer.swf | Bin 13905 -> 0 bytes
 tools/ReactPlayer/readme.txt      |   8 --------
 2 files changed, 8 deletions(-)
 delete mode 100644 tools/ReactPlayer/ReactPlayer.swf
 delete mode 100644 tools/ReactPlayer/readme.txt

diff --git a/tools/ReactPlayer/ReactPlayer.swf b/tools/ReactPlayer/ReactPlayer.swf
deleted file mode 100644
index ee457a7c92999db5bab5c1804898901227834e32..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 13905
zcmZv>18`<R*DX8~+nCt4%_p|)Oz_0EJ+W<0@Wi$!6Wg|J-g)o)RsDb6`l`D3S$mz+
zyVu@zs=KQips5OX8}sd(M|PJlyo=gW$^ocCQ{^Oh8W|RrM24ta!mt~Q_>3u}gq8#%
zeYs9gMF4iFgtn~$VkC(>m+((%*#-nvEL7H|W8$!#MFLUf#-JPi-jBcw*b9ZJ;x2Pg
zvA3C*5rZP1fV{gU0#pHy#nzKSm!>)x&jrFS_YL>Uwxe9{%dhpfTte(e$&lKQgFTZv
z`No5v@Fd;YW!$05xR1zO_f4*?$T5&X2~b|E8r?#;1opqnc|5L-9{OAt3a+K(H#Xe2
z^i_2YRSgZr@zoRl8qK@^ru|V)ZSMjQ&BDcji;I<%1c-16y+HxcXKW7+GM53Sdtu8)
z#j8iih!qQfg1SsV_f2N|=_+n2Kn@XPynu}u`UWTvHf3{e;{)p+@pC_`ez@Fpu+)kX
zqlPy$vX<v>q3K$c_~KYxS_D;AZ0M=C6!dgA7ucx|ggv+~EON~+X3okeWHd^~yuNq;
zR#fclu5eRT|2X_?@4(}<v0GNMR<PMwNDO~38c4d6!QXSS2mNZ;d_O-SVjbrZL`BMv
zeFtz@2@|LW&%k6fB2hjdb0CEGn|50k+57M_^X{7la)eiqz5xKpME3+rm0>HLy4EJq
zJ(V(Q^|`rgnzzeZF_Q$p9?J(>j$-c>V=Fm)t;pF?2~~b|iCU8j2o%eD+y|Uq!GsUz
zkF_%4D`)uYw&ez7B*+d}GNU~}hR;_wOUUR8@SfUhZLN0tIm<dru9dDLUYwntUS9sT
z2I?*uv{ZviK;6E8wZ+Vk;&yg_OUs~`D(O3aIACdUd!v$v%g^Lh=d~+Fj$bfbxS0zI
zENc|z3+tVpcVUms4_Ve{oXs^gmDUC=j;gx4zSiD<+7Yu>Iqld7GaBNHtHt&vHFeTf
zS`+s_p3+SfP^Gh6VmPlk+QlnB`a|I@#OM$sId6J*natj*m5kinG=4I9c?4b!5FK24
zi~6ilRrq1O7j4%JM!F<ChL0)wFRQzLM(ye{MXWd12;9UR6dn_aj}pDt%Z``&PEm&F
zV?=u6yP;*!n$H3AG2bLVDxL?DG4TE}KL6BKO_C_<_E6%_*=_vg+|XifQCZC{xJjP3
zrR(8;1}*e9+i!n5RZ`>TCp2)cm*an>IX<;Ucq8agbJF%!;|5|Aa`&@8l6>+jKMeU?
zzg^fAVjJ7Sy4|$*+w7c6VwyV>Pq=q|*uegTxnH@*D2!8tAU(x5qxPycU9JMqgG%>8
z_0Pu5eh_XxW%GQFHGnq=Ma6yX3Vr?6J6T$AHDo>tfA6!W36@qQF~5U`At1e9E1Jy0
zw%sL}dFKAuGDj!!y`QO?V7j*Fv=|_|dRb$_d>`m)iaT=e$f=3>m{|H~@!DM3|5AF%
zRVwXy9J4%_|FXmAnu?syabNfv6XO3W16sR9xb~pHXP5OzWSo<b$Rx^{GexYKu|AId
zNy+0}Ii*$n(qFyR{Cd54ckOAm|I)cyQt+9p14+NXe=4_7u4RZlUY}q0Xu7S=C3A`=
z4>uht`wL?#I(fUn%p~voH=N+CbM_aI<TeG9?b6X8;o%VT*z?}JzMB@MZ&OsV(a@!k
zxf`LL?KGCKhfDf?@7rLg{g8PC02TQ%Lv>rt+hOxs7vR^S>76=;=D2tVb?Tn?4El*a
zb%px9VGO&Q)2>hO-h^Svd;*x?l7d63Go(X$F16?u{oWb+PyG1;ucL&+>oxScGofA3
z{X9ytuSfr2=2ww*x`9Hk4<9tPgL{iYdR~eR)szjq1H560h;4a%`um<qYXNG2BdcRQ
z#GJ|kXAYO@u*rq#He6oK|CbbvpNzKax9(w}>hx&>OLh&>6tpvbZTfFuu9~G^yrY$d
z?7~S<mYd)BxRhe4@DWEs2arlcd_3rokD*e*>0oLm8cE-YuYd2OP854W@62&|!8ZIA
zjQ%G_WJ~h-w#jd&1V2k$Xr?1@!UVZL+BXEhBkj2(&^JUe{@pkKiVSw6S5S0GuIHKr
zn`m^GY*aAhZ3x9h3AK_`LtI*YFjmC_*@4OU>0D4W6${KChBv%-YRA_E|5XSq!+75N
z2kXG#922P+lanN|F&G*pb!S>Ug&c}S1NXNLBw`<wa-_oZB+I)bDZXEg|BN(0(m`>n
z6C1LYf`@G>*bX$RAe;-e5EQa0WNpf{nUIV}%um6??RLNMzE#0PBVR&i2YsP`{$VY^
zbG*-W;=d`kRrCBeV?|y)Hc5O*0@4o%WA+R25Jj+!U7SI|J&(QBCD<%ML5b(P4D5g{
z(*1QDLx?Ha{5-K`hFtMgi-bq*VqYv^-hbhrx-+JrBl2tMKP-^~q8<l_Y%oIbKDo7D
zhmIkND1we>;@8;_?L&_HuK1n=k_LYgmi`OFbN?@V0K4`2?%5U4X&`LCL|lU%zXU&W
z2Dv}<T)Y>u7kD=HEf10qx?Ak|4yVN<;W^KxQ|dO)Jo|<A8b>J?k`VlWyPt{p9qpR0
zmx_Q%q%tjkL3a9xV)h84pDD->&13L}pdUS?YR6sp3#rNxjW;_4iK<{g`q<(Bh0&7u
zTNJtiipSlqU_01>Oz8iFllPawB5!!)Tz6*>p>K9RP+l|ibD5V0UZJGMBlbwX{~J=q
z>xJrp=8?&Kw}|=&nfl$e|J%^#x4LK{xA*BAtfAZ>%Ch{wG?q?qnc4q4B$dx~d54tt
zgYpQ9FZl@FTgWPd1y?)OjQHdyIeLJbF@!iU6P-N6JRX1M{SR^L1?kxp)M+4MP?JCJ
z4?Cfl)VKtj@x}hE82mrxhRE?9M(5){&FvZ0=^a)3#Pd%j`4KzG(PzaT_RowZqn0J9
zJM@rsC<8#nQv4~$@}ukWyX&+e^oMI<&%rZG=oI=Uc`jG{72e1bq64eo$uq3Y1Nz`6
zgxe?V!9(YseDd-Cv=N@*+uXp1N#RwT`FR|zD+Kav5&0aERW>Pas6}pY>+C>|$#{;>
z@tf4WWsoM!7IDrNDZwQ1yXv;*ws$Xl?^9q6-)7i;3(1SElpkK=)<0-`)G&QVf6osu
zFeN(m|G`ylDL#0h1<3_{aZYIN+_W>UmjYl4c+7(+P*!lnexDtd8%>3OM4d*2?gTG{
z>^lj_yPH1ZzvubiVI0;clGO#l{3>6pI+p<nJqhT?6!;d|y5AXC{}q`}{|%#yN1V&E
zb3d|um)tW%Q_EBQmG{V#!2UC#lMgaaw<Iu*`x7sw&yeb!F(v@t?>|35{|#I6y#@6N
z<i68)imre}17T^V{9<gSS@@9~FsIIdMAmM=i0^3)@kNc)>Rs$p!NuG3qp#(g;B0qX
z;}u}-e~8)Ud0WkDAHCB_;&J8r6gn<vSj<f4hLkNI6&VlP;Rz2A!j9849gMv}4TKp(
zEp9q!pKj^AErkC_#iJC%m}|#gkOt6-e-GC`#zh-wEm8y4g_~Z4fpUmu(54;XKtnP{
z6A%J6WM&w(OgpFn?wl+dIRSZyPTLG-#InQDfp^ck?X;~^I;BRE4WcKR#21}RV?ow}
zp@(dTZNrc?3a6kRLYpl>YsJ!ntb%G!LEF~~>Xb3cQ?b;7d%<V?h6T3K%R2aPX$=^I
zWlGGEEjVH|!Wq?t0-C|qB#aV+5O~?Jf_Ei6csv$K^$@+9RTP@C0V4+tWy@fqX<aBg
zCLtRkRmgX0LEWj>OGKK%DyNj4sUS5Jf$;bP2kyLh2E*?_%=qCQmFremZAw!LlZF(T
z<PtQq9S6bwP#A2obEs7GTi#kU&KfZRjs8RYN##^P_<<M=WP6}lZ&OH`y;@)yZnBM8
z$?eVqzNp<DUBQdYvIE75A&d-5!I*)>2$t3_FFk379^4(3Cz*PQ*m@|m#draDm>SeC
z+`;NV-wLI6+T@Z*@-)=j*9N#(%>rokzA%pI9w-j2U=7XS`lWn<d17@$_VR+q+OYUB
zb#VCkeAk7<cYaYuaRwd1J+yymLKt(IjG-`6b#gWY&2-}?dkxx&d7$^}22SKRlCB3j
zU^DBM2RHH_Ye>$XqHca$hZw~QX#vX$wC!~>LY@X6S3Omp^_s6AbhTVNQ!YE3@mn-~
zH?AUmzt-S5cI|cDwt?t^O~wk*MYRL8LLYxWq`~{GzK>pS#!2iBr`nAt^$9n92D?Iu
zr$jo;(5qpDS4#jKOO6>d6d5VP39k%v&7TM7`o{GgFHpW0%b^*}TlnVNU5dP#`%nmd
z#<e*^ziSB5rcT_o#5Sc;GuVH=(lFwy1<w|MIikr@-khjy80^5@jN%|(|2Ae{fG-Q%
z_GBA)fI|oCxxXH?*$DZ#6|`zG=?Y^n+8Ri)j4J{JYYy0ivjH#pzgl$*1~e+t;6xA1
z2}pG9>8e^V7uRI6V_>+x>;5YMVLo(vnau!oJE9qo9QYE=&dX6~!O;&ELyf)XG_4s>
zM!4hJ8?(I*Ve`!l-hr+bayfFDGh_|*QnXdC4Z3TO@OV08mZPsf8Wh5h%Y}{wE*oIh
z>m<4uQ-_r7C2Dsx@%zJkxflnRbAWYXy7u1_Fks#oZhpLiAdpc;u>4)-KlRtpVMb~p
zuE83y4-CPYH-aZ`jQ3qdxio)mA`B7O{;RBG{Gt*48}!41yA%JO*GOQeDdQnx<J;)J
zauIi8F2mS>HKVkj+rqSvsb|bW@z_eOg{3ZrHQG+sB4*oC%kt5$AZ4`_fmrRnb)oK1
zhGYeTLe?c$l?&Y(^N^yib3!OW^!TEiLg+#040)zp#GR<Eu*pykcHc`-mmzE@JEcG+
z=&pUs6CM-6YM7&LjY*7+*^F>YG<-^%1hs4b@`T<$4`{lA{OW>nCtHtMJ@3<+0e`#i
z6%?R$MYdTBzJ2V~5TLe4Cifuj3tktnY%v%wGtioa&+?ez>Y5&f&oCId7cIs9n2A~(
zYF+MHzQ_b(iQ7H;vLK=R&0tY>n)?s;C9{`|_#W)J7;)|#;8~*>$a>s)C3HlP`|vD%
zx3Hf}n=7T>MkDJ1J|AtVnSZJJR(NE8^ftJis2flWE;_a_G4rCWYX}xY6<M`*I-WUD
z|8PZq3!Aq+xSmPvAS;TS9cX`bdQzfBfwQNp`90L*<SrbeQmDVzT`;pf(tNvWC9rGE
zfe%q0OOC|p=Fz-}z-b3EUb$!6q@LV27i}>p_{y62kPbruiq@Ht8oJB&a@{lY4`w{c
zGkvzb)!Tv`=A1cdzjMny0}fcA!&emP2US{%(|)1TFr0%ow}7p|a81=?d%mS8^!u$L
z^;6k-!h~L<5q1o19+Z8VQN5*HbO>KTf7$g%v7OsL8k+gv&19Y1yM4H!@B@S~|Ano@
zBZCQ#-{X!Km<t#B6)^dE^02fb^bvKI1k=Fua!qwEE9jNv`!~yCCGEVMkP@RXRA$}Y
zn&Mw4<9Cbt7`1<IPP*2w3%=fs4v&}ZGk)ayI=of5z5?qadhdW;GhYT5_^>|@{KVv+
ze*1F$pIKWYWt3x79Afu`AJxBhy&zm3wS>H51QyR~8vgJ)*g`MB9xVju;YuZS<=47<
zF2peJfX5m;A}_#uN44oqkT=9!AIm@DH-wlcmt@dyQ`lq~8{WR2@xeZ=Ef@JbCvD_6
z7_Ru6GVPxOR*{9jFdgbTGMwlg+58(UOLV%^YHdriu9rcAO0Oa-;Op?OzA#s0dakCp
z{6_&3h3II!BnAJw>5ShFg<v9QehjXMZpBW1L)nxZLF<es{y5+p;x1XGA<S3fONeyD
zy?5^QHNn=NmFFOacv~vEt}*Q1q3GmpNV<kioMvjbC`0u|dj4*bHDs5#DC&{GzK;00
zL0%U3PZDr27rcFlaAb=tw|hongkm*V?@{TJFYtWmNNwEt-=Jf=I&9!mq<ti3{|D#e
z4N=Dd<fWJmk;8wq6It><DMx*L8!7uvZ$Z=)!zsFGOw=UDw6mk=hGx*+cLXkJuMm8M
ze+@q921Ar$2ff2mflBoEM7$N*SWvOmCwL0Im5McI3VnSk9F}V;Hh@a5b<6GBPO#4>
zGasx%-jCu>ZWy(HZ*FNITHZ;nk(Ill|9OO@{BG80&(zf3p?M}xs8H1}uv;a1@9b6t
z#Qbh&#KxQ@w`3_q<?qQABNu-x^AjQ6Pz<u$uy+hX-e6uJgeeG~5%yUpg}Jd)oNy@r
zg$hxM2v4AuTUPX{m{t{!rFBwED3akpnp@tke;b5xtO#LzgW2g|mx=CWmCF!oH9W^|
za;q@Kl`Vg#9`dUP&uhP5d!9cq<I8Jzs9>5NVHVTD@8FOdG4oG1;S&q6>dCwQZL0*q
zECDIiVjLm~lffpOEq?iJIGm-TiFrp}QVRl>Pl~Bo4ki`0kCj9#EJ4v5X|FMy0X@h}
zbY3A0cI6*Q2{9I8lz~D&P!}GM)GPU~2%J%lvw@0{j9b^JPIx~gPln4~eB2syhwmhn
z%Hou|@X7bv;gfs>Re8Ofk^6m02TS1Lb6*CMn@0#Jfj*-y&q>S$W0My0*cLvdkt{qi
z6bw$1Gh~!fNdzH!o3P0)V0+^b`-;M!5IPSKO_3s^B9A5rU;`mcYh@(iQ&p{T_`+A*
z0SS-aZp}uC`~9ZXLnKj=&^~=A#YWutgd6VIpQpYvfiZor2`U@$4LBdRFcDpcKd0Qs
zM=n%APNWo^h7R--ZDt4u??suM8-`_?6bqQk&jUArFaR@vETct2Rg9>0JEV<Q+<}-V
zPNHTa%Nw!Hy#VhbN)~{*f_x1K?j;#~Mb!u-3wg7BL-qTy^UVPvnV305ZLgP^L>Gw0
zt0;OTeasJ=L!}%Xmk3f5Rd}P8#*=)e?Pp*&xRv9L$#B7CJ7G7U1&$ZbS-#9^0p(1Q
za)uFDV|ZL}ImXJdI?7n=Sry?=`dOz$4tYlSp)-z%@9=--29G<(dm{b+$Ry9plDh0a
zr^re@MEQC|#0$`t8AL`<@88(Ap_41b-{J0NYNiwYLqDBRi=M>i=f%gdv5oJdEW5B-
zW(@{Md{D{m#EaWQ)Y9Tl(T3k;r+3g!pZ)`W+%Xln>lL#2L)00Irh3A%GKm~gjC4lU
z9nikwhQFZ@lI(l+L_Yds?hUI)<7u+k=?%3y{>Qmr%!+qFH|zYB>x$lWOQ|y^f9#Ot
zbx`}e!I92)ypLDt(5OS;a9bTq^;s|NDDw|K^0bu)3qz2n5Q(L)_WmIU8`%}Z=RW$T
zuHNwGu9!@GyoFV19{4SxXoQJ--J0Uvxr&q)9IPyfarqmw^nZ|aKRfkNfYVU|CE=IT
zDi?LU0$-duc#rnXz2XDVq+{<{WU6e<bA%wE`%BAy)qh=}6*%YRn)?>laiy^CQJlp^
z2>eQ71}qO|B*SeQE<Yn_MZSTMA-7(&TMFM8SaA7;S6_XVn|Qc+C87_;k87DHH}5u;
z*Fh%-vg){oG<Q4<K2z|@bW8?7{ueQW1X`6|HYssJ*l@}qzet+>boNzBOstQW-Q)e%
z)f&P`x9E!RJ(OPJyqF~p$E(Oi#)izhc)N5?EV-1styFaK*B7k_JFqY6j!?3<ax))2
zxhv;Xx6b#;U6u=yssR7TROg4im$L45llGmr-4{&)&!IqJ)z>f2_iC~-4I6<is@ye3
zMt`Z{UAz%^Y6?aaGdPB%(2<{k!Ygk8<VulID;(4Ylc(F<fv(P*zH!O4rf!dtKHtX@
zxfq~vG|j6z9!qF<&dagzSqmE;A@3WA4p-GJ`lO#(7S8u<w1~bqa0n>J!%}Lj10tVd
z<Qi^7I#5j2H;9%V&(QaaK1oYSasJsd;={qh(y_wM#Db~BFi@;*qq1J8^BcPUK{%Fh
zWC7gMi`WpEe%6W{nnQ*7^(kCEujdbTsh~*Kxd|!uEF~X^10y;FtUF?x;IXdy{r!p&
zMf7o7^pT*dtk>jb9@HX~=XD0+U(#H}h%{Vl{dcnQ<<3Wv9Gf7psav*lVWz2+N=s>Y
zi93S_%5~M+<<>`{{lxq;R_Mkrq&-Bb-2m)d&<cu;6SO32a?ZQV-xL%yc3~S_mj3k~
z`xrj&z>TqJiscv`EaoIfej249HvXZY(TgS$78?c#)PGwL7GB@mB`FQT3axGlId)pp
zy7K-l-}$Ctw{);XQ0D()sBcfe?WlHUDf<wsLCUvkv#K9bqU2eQUzr-&qwVE&^(7!?
zeL^W?f-Cehh^605DxPjkYEJ^gwvcNZel{XLkzq{4WkIO$be_U#KN9^4`As5|rY@I0
zB?%JvGvV(zg&`&HK=;juZBfEafW1m3PYbsP*+sz$k@-cOdNzafP^hHjqptO&EpB~D
zRsEK>Muyq51(hlfeKHk;SdQCZRlCL_d&Rhl<cgXqgnBtg3}mtPNjUcGRa9(jd8$N`
z_=}QUU4%kN@L_5K;#+c*V2Xqd>pJ;^T#=WhIc(N(1JFmY1*~E-sR^HkZm?IFX`#Vh
zEJiKZ^FBbw7HH9+eO2mIKQMNIH`FUd%zg|HlcVkd-II?b4q~`7NNKL~^MA4=uYjW2
z)3*{H@-ewYLgiRR#m$VkKA5(Qupmc;QyJaZGZBkvzC}PUIgyO`j;md$pRKeV*@F-k
z)Zy}-%*%*6|Fyqk+Iu9?u7x-&PGSgKv`7S1DVS{LgB0cV<vZe~u;n1ZeN4ICIu~MW
zJZVv%C7-)23nK$3`{C6g#BW|NBS0b=Ix40jOo;kO@sS`-p=jLQ9^>ajWiUFKsa`s7
zY154<vXIkPgcucgsZubW(4}%u0U8Cc>{#DuUv{^?LwtM(ss%V4E87{h{Mtlb8=ITE
ztMj5AH)uJ(oeLv~k3fJhdunMjj(y*u8JW`0kDmd>pjAo7jgL0b@tf9bpx`Dpz@D76
z^ql=GnR%7Jt<B%6EJ2BkfmkJSQ(Nzm(!L-gZH7ek+%+f!<_{`%!<uFk7R!*}hT3I1
zBV@v4w<tQpP(F>AbBR}}N+{3pg64Cw{BkEN?*stZ?Rr)JgcbXb)eV3pg~UW>)Q9!8
zG@CTVoMUF_^#V%*2_plD)%XoTfyE3xRw7uIgmDS%N)1lPg2s*MpkTQG4;AYXQ_uoC
z>u}N|G}qC9eh&lfZ$H05%{b2*^SpqDbp17tuh%T&a;w(3ErtAUKN)=8rY^&*FL;8b
z)_YOT=`@PmFXy*bxD*%GfFcK4&DPuEVjpexaBF3vDEebI`h5pXui|^rICENBZ$U29
zA;uw;2?<o8^b!?IFp^&;s&Fd~G+}Tyo+a^c`NaWoc{!^M`rZn2xdf{XvfdhvM{36<
ztyq8@(DWcII)e#cd*r<pZE1g@hBRcEf?g1%QV{NYhP;dpoV2VM+OP_<pRTDM)Nl#u
zWJTfv;$kqa^~#0TSl=qBPGdc`39ZTu_spp_wSb0OpRWBkoA!e~?7uxN(HC<$3r(((
zw@+-mmP}+7SBkGdy2BbNxF#pOuafx0IkWh5Eu|HziUap7NUMm>II&VgnKuJeJy&d3
zHv{byV{ov@E9YCqx96F2Q$<0Ox)C;v)^X11E+st>nCkSQN3%3kQpHswx09@me~|dP
z_K<)+qzL#r9KKqu1u5x5s98k?$k2n)CNYAI%SNtLabY`G3~Whx+D&o<@bm>_TYA6>
z?<~KQ!=8Tk11OIS#c?jl?7C&Tf?06~F_iiUsQP;kisA5)Qx+BlMpzc548f>|{e-w{
zoUy@0lFv*!AxGkpEb1=!IMj+E#n~g{fP-EG?g@&tHU1`R%xAvQA{$SB%ooBTOR9?&
zc^rmk!nH{J;deUw@!k9v3#kx=*q_37gqC0m&*)X6N^;rn=*N^n<sOdn8>k%XqOP~s
z+zj1?ysG%>8n`{Pe7H&z@FKn&LuWKPe_g^Q_#2hb7iIvR*Vd9}CkIXWhD!LN#?0>V
z#B(Zg&58nT-2r&pn7CNR-~jX;X4pA36!5)vMiD<$jb?dMV8qa5FLg)yh?TxyTjA+!
zE@H!MAtvrE+)@O4YLu41Ys^D|nS8`hVU}hTqTN|@U(H=3v~TeD48dmReavEAT~Vj%
zy7X2Gqrp!6Xx;Bf8AOc>x3zK6JMNMIJ5DN%;8JncIknO-^-+wd3lgBJwx1M6U01Z;
z<R3R?e6n?6gK)AEW9E%<)T**_z4wZy?Imx|t|{BJfsby~ljubGzht0@$yjC%#KpmI
z!s;Ph5&76Q5w?l@<BT6<kkZD@R#jZF!(OD*c-PiAp7X&v)Q5*j*|YWWaVSxxDX!^j
zxu14=<hZyk{3?ywZ35lQ7@K?W+t}utp<FpPol%d!y93<gy#~H>;G5Pd@lpoW+jzjl
z1LuvRQ+So;voTigbaxU3Fs{j_#pT+&lm$b)MEhneN0L|RyJZ_ALAs%uE)lVIb+%c*
ztuP1-W)_&d+@lC<EU)ri&n%~F2yc;+^vT{Jf&4#6=Md*Uk%e=z)p(BK-~5riV|&J=
zm!0YL7(T&kJb?Y`2sjJ|(vFl$D&rV)qgy4@sbmDYNSeIHVUm~H9)YK$Vqx(4(pV10
zL^T%;zgR2;quU14xrl~+O!U}^hQUnevyt~qOz1O_P3!ccH!|u%exyx?*Cqc*n+Ttg
zk2bqArl%T?d|}o=+q->Xt|lH%asN60m;%~t9Xg{OGk0zBjB7iTa<j>ZC}>ca-i=$n
zEL?8N=|po;r{Sa=)bOtdYMxn}*#6bFuCg~}wW;QvDoarIFJ>-{;|w(!_Ei}nxZ*9l
zmf1Nw=|Lp4dF0obSseRJquS-x!xQL~ce9<vK5%O3(%#zKB3NtXw4uw^LC~qHv?r+q
z9D&yE4<0y+s?H`Nl?h|+Mgi!~aU`XSC`C)E*(!^)8zx#+CsGFECKa4zHA8;I+I3m(
zq>gY+Mq<DiTb$L{{qz<D{*xtu!keDccy2hB5+6br?*s=>r#T8NfqcV_Oh3&yap)$C
z`EUDx5r{X@nznr%#z)oe%ekYR00Rb;vNfjvCqBe>4Y#?a63-Sbt2uX&)azcJOh=W#
z!!v3Bc9RoFceuiXNm;3bhQ;~`_rOP$9CW>&4x`@<_QLm;D8Xxwonazo;&;OKqqB4|
zYkali{%|(#uzsyc(mK~W#sVa)i_oJP$N&r!KD!$+ET8Vmz0ku+3lW)5Z)AzAbP7!n
z()Qyrb0JE+JZtpoo@F<jK5AW5GWLz1uSCRtGWFR`M*flg+UnR7{%2DAHM}_?cN%-?
zZ(xZWp4Me5khKaByaWCGj{hOfrWV$gSFlo_g{X`i<l1X0^P!Z-Ga9bvJ2LmXNCe=b
zP<ZTwnkGo8Q%cCHazs&D-BkSOjb^qoQLhGAEc9=wG6pQ7(a35u;I~&X!JT~1Zcro3
z%$pVgJD-(r)BnMM%^<DVwUzCKVKB_(;x%zAkMFiL5N05Y{&4z1a8HZse2B?>tMlkR
zWj#JpIX*J>yCaR>6+2sUBZEiu&XUXBvV=Mc+|1F^>~GT~GSX73a!|jRwZJ={mUR-v
z1lb|`PPZ6fwS<H$3|IV@mCL_7jcG4RS*H_MOpf~B%&!^K4b;+t_6kycI_(F4upM{>
z5EUWvYqEns<MpUlmtgSZk2>8;m2<-^@L-3aPI{SvufE9&tw^^6dDh6`&pTPG1LQ*d
zWdi)8$com;Ux7s3g#tbaM1*sM-Gj)`P2qo@jrF{rS%splkmK$K@*l5>UUvL0c95S7
z485Nf-=_x*bdfRqgY?I%Yrf?{2tx8ByaTrVp*~Tsf!jpjao>92_~Cp?mD#kOrTnTc
zOW+&EnEJKexvS7$ml|mmu?FB#<YXTHs`%;W<zU+K9(YFcu$tVJRZkx$kS2-NL24Ij
zO!722ZHmy9snZ?hH0e-iB1UOMX}rz*DKz#q%{&Cq>0dh6A1GG8|4kEuEGL?MKhnt_
zB_egg9Lr0br%Mj4RQqf_P;8S^qCv0f#bA1pYL@}2`t5jO;gE_qzyD1UdbuqlemE*0
zK{1IuQ2g~ylOkmIqRNP_Mq1X!_C8D?3&V0l@h(OTcyB$3Qx>fq&)AtKVDr%=26RvW
zdd8=j*zWx!5x&L<*cx?N8^;hXSOFd5({_KaIVnrN`2#8z;J<!t)OSPf_?-nUT~_Rc
z(u=y|kl5O1?C+bp+H84^bH8XIdA>e`A4n?-(x=IrH*_Zr{6$ja2|MI}tu6ksElV%Z
z?YN5+PB~0w@=fynH6x-^NIb5{2S{7-%9jCeCx^o;CKK~}CNMC#=#$#;bED?A3B9f-
zgQ)<<^RF^~ykc;HB|AGM>Fut`xr#jXGM)xm@>uJ=WPir8L><Ol8I+o#SZEI_xpu{;
zlDlOD9G5VhTx2dvN9Dv4H+}9w?sTAX69+S|U0Y9}nD<kqRj*5u#kNw&;OtfLdyGCJ
zt0AGxwOfTq&%ulnGHLmeP79M=d@Ye5-->*U*xI~febLJ6Vx`TjKs4GfR9ZRb>7FP#
zvaa|{I{vEIP^8~=DzZn-hj*ME*{(J9|F$*t{Q!+P<%T`4`5JEtnu03-dY(ecVMpeq
z?YA;G1W2$=@ZuLs2kyZ%_NH}{Ck|+UvCvRfwL{<AWmZI(TZ~`@oWrhZUeMK`(?+J0
z4idUDXqlx=M|y(L)efDMJ+K*-Bxau}v-|!i5yf(@-JgBCY?!)`qyf*5Tkb;B{k?vr
zX|YB-s;bY=fCE1VV>ULg>*^^7k~qV+hemwYc1^7mC~fY3jCYgH*6QjvX{4kwk*rtR
z%1nQ{DU#v4%4qv^dMn3(QSEY<sAK?Td<e-xc|kY=rWh@DRzkldI_BI=NA;LJy64s2
zEf?~Z?lhUV7Ty4Z0J-|AuBb$f&aD|Gd<zlv*GP8U%)xBf2VXB*!?e!C1LEf>=>~z)
zxVtldCYKScz|ULXwB?jMv>&!Wr!VR9OVJp0#$qNqoRkBHtgZ^Px&ikd+=$mfb=xy-
zBr?qr6pET_Vbjser6&isj2r_t(~>?do_}{KfZf|QS-ndZ&un`t$50Z-p$m#?X7cKE
z*}}SVskE#}<sN1?jLJk*S#;m{m451PP2CGD$g8*~#&U)XvsHw{);G4t)yu4&T#s~W
z>iYBAU$~Q^B=)z1i!+g9dKuOt{g_N=pLZwEHX4>s()$x6_!`UlL$zovEfj=ZQ%$#C
z11A+4**WKv<$aK(0AbraM@(tPD$_~wA$6*a>d1vQwYVr6%!W*}OIAHc?~s){8rdOh
z0<r_%lfcSYCfSNZZHwH8TdUMA>=T+IqB9&@X4X}T!$)bm?1A?&gu6cv>+;l-U(?Pj
zKIC+Z)W4hPF%C!Tz3;mQHzYOgEHv3PqY#KR6u9@~Q;b&+xeq2&sKyQ6)G!wmZMe13
z;5myI@20R`8q^&}o6NEUN1H|uCEDbr4<glA?<48s)Qia$>yNqA9gXTv95`spmDWz$
z%c61?fV0{cE*#oKS#?uZ(pH;TppwC6qsU5*$+xQ3Rig>3GldCA#JvnxuPg)83&P2+
zb;=wpg8FtK{L7PxRZ}n4H$F^&s7ddSh`(y{i+n8ZID;3yb(|-sCjNAyeBAp%XSrH<
z0=R8ie-Gax1mtJ?fmJzF9N6H}Rq1YNnz5g5*?3sicE6#D$QVba>$MA)8$a8Ajo=te
zd|*4zrcvgl@w)c33sT!ATA(?lftorVQXfyJp|BgcSL@Q<Zhx4%1a`zG-*%ulCC@>$
z`>g6@_p5U@ILyhbjTx0<;09B>v*QZMg*$w76k|?Ykcks%(#Kf4qg8A){mB>I>mqb<
zu;YdgxzsAdN~ehSFzK1{F;<~E;cHj$6iM1uNuEbdoew<BG6B9Q-2L8>vm94oH@$1E
zpK{2$NV=q7vPvKY(PH(*(zs6xQYd(zZJ!DQ+)$S6?zUgsQ(am#zVIJ-?lA6X=ns<z
zz;r`bx`N7n&9?&kSy`9u`B(?npm84y>3tTIiGr@uK+LurEdn6S(oCJ5e1?L*JPaV_
z1+vO{D`rS2)#%4k9QrMDUUC(TIF@MM=j$*j8h!5VF)Z8%=X~CS&S<<0p`oS|59Cw>
zmOL&VZ35N>G?o<5n`Q}>rp2Zu@KOQPHYFP}IZk>{E$;4H_Cr~N%Z+IG%tkI&hN((y
z%HLbIG7_snRr@lsn?dfA)6U4t+Di@T_2vz%+!IMQ%UiP-aUkUvi-F@$+%y2TRe{Y?
zu$I6Y5L}5V8ZiLfv?}<jL|1M0=orCNO#g>2dXfqv)Sq5_eBE?#?H0b!r&d)fP)T3i
zGMFd5xx2u;Ma(2~UZ$gq6H^@D;Q<bNCqEtWQ7*k-%dCXr-%fs(@G+Z3AXOPp=d=b(
zSrpZ9Y&FKrV>7tl#2LDC@bQ~_8)Pb<CCawqw0nEznef^^kqKAa{qZ&dStWb~+hDUm
z`PH9x!^L;Z*<a`yAI4iEZDdROVx2>uU#%_OhAdYgSr6gFE@7^0{VNnYvBVAy?m1Vd
zvH8heg3U6MB@>ki@OoJV<T`CV{@*!k>4pzVHmO|fa#Wlv{j4ITV|V^Cpyf{0Uv}>Z
zrUo*KBOa2hJ^rPf&&9V=14)pFBWC>W4vdaWp(E_@(Q@_dJ%d&^Q>(%q)149{oN=2x
zQdv<!)flSqKq=O^AD*j~#4ov%2)@O*Sck<?@%NX-(hq$SX~rlf{gEMpfb=5yRV*oJ
zFsE{HMg?cas5i6_i=X*El=ARs>@jJM-tsvt@;SdUd5?4`k2zGyExP)O#|AOlywn@(
z?0@av4>J(RzQW0K21S(QDojYEp1jle@=mc0FLz92++y;B0x}$ben3d3<*k&*Ekz+}
z14R`#ez$F455Mg+$V12x%5q$x!f9^PE{O6}>&1{5PBJcj_ho^)H+v1ZjK#aUL(#{I
zQV`rM8y<dhGVL@hk9m@1*{sQS?kp?#TwymC@|n<ZUn?-^n9tr`ihfB?^6YIY(Auii
z*=h)fb~7S2IfN0hA-csCP6ZXfM&Gb7wMe~6eD(&;j2s&YFMPs;|DCgTGu}g<)aoHe
zc{31RFN0~!2%ds=$m6?oW3Aj8HI!%m;)#2v8#}a~?dD;Uv&P-!6#TrGr=~92vzO00
zV#49%pT0rz<XJm)<CwC^`^a9*%G_ph!}#S(n$fe&Pf61b{WA9wrQ0RFk<PdglW{ID
zF(*S0m=qk=u?>7-D5A!xBpv?UrH)bN?qz7Y&i*qzO(rXBoQ&eIkzqBZGBjfIM1FWV
zWuFs<zPM-7gJ01LcS1pQ;NbTU!Kx=ybZnZuv-zb)o>e+k&(`e>`v)d$Blm6E`SPeF
zm8e9OD8y4e1>O^3UDoiVNubkg%J@mKu2->&F7439AUh-FH6BD>6kX?pj>nLneRTY&
zMWZM`m3=3pEPF(AVPYkD_~obrUMf-q4?RyBfr_1Vc(Uh8flW1Dxt2-W=n?gB8C!%S
z1GMLgBg3EUr3&(iWapa3=DY)mJy3EYTD2{TV{G%!cCR|}I)E>HsJ^jn`WPs5LJj|~
zwYR}UBgx+!6p)j~X*f$g-;)<e{Q=y~Ykfvk+!0I1ESd~*u^#geOEu@}miv)g)KpIi
zNZJONCnBUk%F$Q(b!buWso#VBkR;vYRCDm^;1pPKE}i<z$zX=R=|pQp{S3Y>lLyPG
z6kF9gCUl(^W**zAGLdoLVVggzq?q;1IL`JZ8=l8u*C!(`8~89SfU71y#$hXsYE<E;
zOzNj!z!VPk%m-6p);GLVdmkFp9Rz%E^L~R`UFFMkcYm^0)VJNZ=<4WjZ)yQTT=e-!
z<em?M8G24DJg)s2E=po48J4IM^Z6O%vbd$buQCFU)_7BPA%t`ZDD_4k7Y-@-#Y}o1
zI&aa#{~B~~hiE6b=~#^wY5z^VkIW=O@{WWE^hjE$($NaCT%*{$<g4=D!5HgccFgkY
z@^^*x<tSzlX{1^t75MdL5H}WaS62E1pjgTxVLPLT4o|O3Hijy<Yl1x6AZMsLU1B@$
zqHA<M-E5s3z#cCmlNfkY5YAIdQ>o`&sP|@jP&%R-AHCpnSgJmW*>RZQiZQI$;6-^;
z*|s1$^+a<4KuSf*+nWi;_7D0lcaqXJdxU#JXFrv0A*h&8WYq0~<uQ);Gly~m%drdv
za`lLE-`iUzvQkO<g#8kpPe1CdQ+25EuN!7ZD!1+Ij!b3gyqfbIZQbU*p4H#(d7mPk
zTc)#Mcd1--_l(Uj$NDU`&2_wSq@RFRXT}|~+twBHkvVxH|9~AdFN_T0E@p+Q5(qL0
zoy{ve;1-pL;?5Y};_aq{ip2O^&>RH?LsD7sy<9bcrV1Nx(ht{i?RZBGj<Oi6>z!&@
zp>L^fv|Rdgi{9tvW6OySLX@2G+y#*vbl?gdnrq_+TKd$Sns%p>M83sB`#?I5@ybJ%
zLj}Tk8Pi=okbJgTI=5yP)npxD;aNwt>82@UrAmX3iszkqAy?2dmSDDQqSc-bK@lQ+
zoatyxkpbZa?7KRqvSE5DW1qi{mr4{Xn%^UvY`Hj0ne#dgK@q8{x6KV%s1rH(**)pb
zkHe(=kdF=)B8rW`F;0u6ryZI@N2(OVn}(=l%zhl)cd)+}bVzU)%zmLW#d@nIBgtxs
z*{iU)EkqxdqkX!LNl`2@1W_=?lk8hFlic;fTilMHl_tUBnSQe=#q{OAG0u&=IC*H+
z-Wd{Wx<yR_o~!kgCxr};IbkbR;i}vdJD4rnZ9~hZh*QtK0IJzzrh3Wcl{tK*H%imw
z?{+!oXk?Cc(49%6M5)VwLg3Kia2`f4*APlS6&Y5swISkMr}2r2We?LjehGze5q~c*
zf?#JGBHTU*>fr6t_f(1c9DA*JTA;fZf}yLwHEj$hT7q8?nL)e*0KMQqx78aHM)myR
zX27iwKW(g2Fe7)n@|1OU2>7vaVWp!&lZtaEg_vq%?NJ_fWkM|&C2}EHDcxi9v6(zh
zDQ>N}xPntNK)30klle}rAt%ARg<1#vU>cZ3VG~%KONSh88kF-yN~#O%(S(eeTK1$%
zq|lzzhd13SC^SoUy-A3(wN&7z>r-8|O-T<|n6zE=O)I5`FkMl%UYg9}A4V8P)(f#Y
z>qoZO`ZAI2q%XcZ+WlzmTrP_$y&B18nri$cgq}r0!pd-e23CvvmiC)nZ}>$e_Y2A*
zxjC=z3hrSlJL_XV{DtKzXa0zlI^SsGgI&8x_R}6LFV6f^xvT#=Goq+uA&bU3XV{t9
zviMxBg(i|`aK>E^(1pgeFhsINO(gXWG&vJrE9lS8$k0@uInGH<56)(-TC*-POtwTa
z?1UQ5OL>LwJIdt@KOmpi+Wcd;lxhbc8x<p~zpx}{7`U;{Gqbd_ix@SMD2sV<BR`^J
zyMaBVQ=HVaQ;u=ApI=mC{GjHZP-l5kOKBBum(42HFivczdx;`)ME`e2LRV1meD0as
zHJWr6+C>|pq+gv1|D`#CtToC*wz6I)o@csFDxc?08D#ZyL{fBi2wdbYoSrCxGV99c
zecg|`BGIEqxJrpAWBcj|Av8#Ni<-svac=awEK5V<wz2RB2qi7lcgK<rlkiFh>I25E
zww+Y<m459`&AMj3nY+4M;-ew9zV1&wP2d>EMzY{$N4vzJGdY59b};@vx<cqgyLtYN
zIj(NYAot4$kEbHF+wj|Jm6{;kCy3AaZxT$)6vKMA>J~%NwOUS-YDKaU$AxN~+kn;D
z%Vh<fZY(&D7w4*2aR#ZTWq0IqK|qSgS<8rVf*<07dCQ+Tbx1;M`<5z1xNN5#eJvB6
z($Omm%d2Ckd6viZi|n<&Op3C74kuLluG~ocPnF^(=8-}C{3G)MS<&IBCPZ)x`rLlz
zQ|7+~EEB(_5FWKxmpEgV_i=e$5GxO2Fc+2PT$VF83l9`64m`5*&6Qc-?msRc3;5B_
z!F@Yb#U0O3G!v}r=rD`yqr^e%Cv`hfsQhfk2u$gB2Lf|H3~ZuzteaT${F)tXovvzu
zB!XG4{ln!*LO=g4!rZ^)VXs*Td=e1G{wymIA_Cz(pFaA#CKv?2yno2oz^cv()pNVO
zLxYxWM<YSZ>m_at9qgAVZ4aC+#rJ31ehEL573wx0?V0V~_@Wugz_*m7ujbM7K_keO
zKewUabw(;1Ufu2$6cB948{FVN176h%m}y5|aZVG<Df(YCfYByi45@Mq`^jYQ^(L(;
z=Ias1b3=>`kxiXduyt6YorAaTkH8ZZBQ)#JceB50b+tao&IY1cp6l4Gvp&F*pOIc{
RqIW2BVhCTz(3;UA{|CuOHLm~w

diff --git a/tools/ReactPlayer/readme.txt b/tools/ReactPlayer/readme.txt
deleted file mode 100644
index 6d22437d..00000000
--- a/tools/ReactPlayer/readme.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-load LOGNAME		: Loads event log from LOGNAME.txt.
-play [PROFILE]		: Starts event playback. Profiles: normal (default), verbose, fast, faster, forward
-pause				: Pauses event playback.
-step				: Steps to the next event.
-reload				: Reloads the current event log.
-debugmode STATE		: Enable/disable debug mode. States: 0, 1
-showthreads TURN	: Show thread markers for given turn.
-clearthreads		: Clear thread markers.
\ No newline at end of file

From 928e8b9157c874347e92db92deb7a95d5a39209b Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:06:24 +0100
Subject: [PATCH 63/75] Removed test example.

---
 examples/src/Main.cpp | 488 ------------------------------------------
 1 file changed, 488 deletions(-)
 delete mode 100644 examples/src/Main.cpp

diff --git a/examples/src/Main.cpp b/examples/src/Main.cpp
deleted file mode 100644
index 3d3bb8e4..00000000
--- a/examples/src/Main.cpp
+++ /dev/null
@@ -1,488 +0,0 @@
-
-//          Copyright Sebastian Jeckel 2014.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//          http://www.boost.org/LICENSE_1_0.txt)
-
-#include <cstdio>
-#include <vector>
-#include <chrono>
-#include <thread>
-#include <tbb/tick_count.h>
-
-#include "react/Signal.h"
-#include "react/Event.h"
-#include "react/Algorithm.h"
-#include "react/Observer.h"
-
-#include "react/common/expected.h"
-
-using namespace react;
-
-template <typename T>
-class GridGraphGenerator
-{
-public:
-    using SignalType = Signal<T>;
-
-    using Func1T = std::function<T(T)>;
-    using Func2T = std::function<T(T, T)>;
-
-    using SignalVectType = std::vector<SignalType>;
-
-    SignalVectType inputSignals;
-    SignalVectType outputSignals;
-
-    Func1T  function1;
-    Func2T  function2;
-
-    std::vector<size_t>  widths;
-
-    void Generate(const Group& group)
-    {
-        SignalVectType buf1 = std::move(inputSignals);
-        SignalVectType buf2;
-
-        SignalVectType* curBuf = &buf1;
-        SignalVectType* nextBuf = &buf2;
-
-        size_t curWidth = buf1.size();
-
-        size_t nodeCount = 1;
-        nodeCount += curWidth;
-
-        for (auto targetWidth : widths)
-        {
-            while (curWidth != targetWidth)
-            {
-                // Grow or shrink?
-                bool shouldGrow = targetWidth > curWidth;
-
-                auto l = curBuf->begin();
-                auto r = curBuf->begin();
-                if (r != curBuf->end())
-                    ++r;
-
-                if (shouldGrow)
-                {
-                    auto s = SignalType{ group, function1, *l };
-                    nextBuf->push_back(std::move(s));
-                }
-
-                while (r != curBuf->end())
-                {
-                    auto s = SignalType{ group, function2, *l, *r };
-                    nextBuf->push_back(std::move(s));
-                    ++nodeCount;
-                    ++l; ++r;
-                }
-
-                if (shouldGrow)
-                {
-                    auto s = SignalType{ group, function1, *l };
-                    nextBuf->push_back(std::move(s));
-                    ++nodeCount;
-                }
-
-                curBuf->clear();
-
-                // Swap buffer pointers
-                SignalVectType* t = curBuf;
-                curBuf = nextBuf;
-                nextBuf = t;
-
-                if (shouldGrow)
-                    ++curWidth;
-                else
-                    --curWidth;
-            }
-        }
-
-        //printf ("NODE COUNT %d\n", nodeCount);
-
-        outputSignals.clear();
-        outputSignals.insert(outputSignals.begin(), curBuf->begin(), curBuf->end());
-    }
-};
-
-
-template <typename T>
-T Multiply(T a, T b)
-{
-    return a * b;
-}
-
-template <typename T> void PrintValue(T v)
-{
-    printf("Value: %d\n", v);
-}
-
-template <typename T> void PrintArea(T v)
-{
-    printf("Area: %d\n", v);
-}
-
-template <typename T> void PrintVolume(T v)
-{
-    printf("Volume: %d\n", v);
-}
-
-template <typename T> void PrintEvents(EventRange<T> evts)
-{
-	printf("Processing events...\n");
-
-    for (const auto& e : evts)
-        printf("  Event: %d\n", e);
-}
-
-template <typename T> void PrintSyncedEvents(EventRange<T> evts, int a, int b)
-{
-    printf("Processing events...\n");
-
-    for (const auto& e : evts)
-        printf("  Event: %d, %d, %d\n", e, a, b);
-}
-
-template <typename T> bool FilterFunc(T v)
-{
-	return v > 10;
-}
-
-template <typename T> T IterFunc1(EventRange<T> evts, T v)
-{
-    return v + 1;
-}
-
-template <typename T> T IterFunc2(EventRange<T> evts, T v, T a1, T a2)
-{
-    return v + 1;
-}
-
-int main1()
-{
-    Group group;
-
-    {
-        // Signals
-        VarSignal<int> x{ group, 0 };
-        VarSignal<int> y{ group, 0 };
-        VarSignal<int> z{ group, 0 };
-
-        Signal<int> area{ Multiply<int>, x, y };
-        Signal<int> volume{ Multiply<int>, area, z };
-
-        Observer areaObs{ PrintArea<int>, area };
-        Observer volumeObs{ PrintVolume<int>, volume };
-
-        x.Set(2); // a: 0, v: 0
-        y.Set(2); // a: 4, v: 0
-        z.Set(2); // a: 4, v: 8
-
-        group.DoTransaction([&]
-        {
-            x.Set(100);
-            y <<= 3;
-            y <<= 4;
-        });
-
-        // a: 400, v: 800
-    }
-
-    {
-        // Events
-        EventSource<int> button1{ group };
-        EventSource<int> button2{ group };
-
-        Event<int> anyButton = Merge(button1, button2);
-        Event<int> filtered  = Filter(FilterFunc<int>, anyButton);
-
-        Observer eventObs{ PrintEvents<int>, anyButton };
-
-        button1.Emit(1);
-        button2.Emit(2);
-
-        group.DoTransaction([&]
-        {
-            for (int i=0; i<10; ++i)
-                button1.Emit(42);
-        });
-    }
-
-    {
-        // Dynamic signals
-        VarSignal<int> s1{ group, 10 };
-        VarSignal<int> s2{ group, 22 };
-
-        SignalSlot<int> slot{ s1 };
-
-        Observer areaObs{ PrintValue<int>, slot };
-
-        s1.Set(42);
-
-        slot.Set(s2);
-
-        s2.Set(667);
-    }
-
-    {
-        // Dynamic events
-        EventSource<int> s1{ group };
-        EventSource<int> s2{ group };
-
-        EventSlot<int> slot{ group };
-
-        Observer eventObs{ PrintEvents<int>, slot };
-
-        slot.Add(s1);
-        slot.Add(s2);
-
-        slot.Remove(s1);
-        slot.RemoveAll();
-    }
-
-    // Links
-    {
-        Group group1;
-        Group group2;
-
-        VarSignal<int> s1{ group1, 10 };
-        VarSignal<int> s2{ group2, 11 };
-
-        Signal<int> v{ Multiply<int>, s1, s2 };
-
-        Observer obs{ PrintValue<int>, v };
-
-        s1.Set(555);
-
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-    }
-
-    {
-        Group group1;
-        Group group2;
-
-        VarSignal<int> s1{ group1, 10 };
-        VarSignal<int> s2{ group2, 11 };
-
-        EventSource<int> e1{ group1 };
-        EventSource<int> e2{ group2 };
-
-        auto hold = Hold(group1, 0, e1);
-
-        auto merged = Merge(group2, e1, e2);
-
-        auto joined1 = Join(e1, e2);
-        auto joined2 = Join(group1, e1, e2);
-
-        Observer eventObs1{ PrintEvents<int>, merged };
-        Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
-
-        e1.Emit(222);
-
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-    }
-
-    {
-        Group group1;
-        Group group2;
-
-        VarSignal<int> s1{ group1, 10 };
-        VarSignal<int> s2{ group2, 11 };
-
-        EventSource<int> e1{ group1 };
-        EventSource<int> e2{ group2 };
-
-        auto hold1 = Hold(group1, 0, e1);
-        auto hold2 = Hold(0, e1);
-
-        auto monitor1 = Monitor(group1, s1);
-        auto monitor2 = Monitor(s1);
-
-        auto snapshot1 = Snapshot(group1, s1, e1);
-        auto snapshot2 = Snapshot(s1, e1);
-
-        auto pulse1 = Pulse(group1, s1, e1);
-        auto pulse2 = Pulse(s1, e1);
-
-        auto merged = Merge(group2, e1, e2);
-
-        auto joined1 = Join(e1, e2);
-        auto joined2 = Join(group1, e1, e2);
-
-        auto iter1 = Iterate<int>(group, 0, IterFunc1<int>, e1);
-        auto iter2 = Iterate<int>(0, IterFunc1<int>, e1);
-
-        auto iter3 = Iterate<int>(group, 0, IterFunc2<int>, e1, s1, s2);
-        auto iter4 = Iterate<int>(0, IterFunc2<int>, e1, s1, s2);
-
-        Observer eventObs{ PrintEvents<int>, merged };
-        Observer eventObs2{ group2, PrintSyncedEvents<int>, merged, s1, s2 };
-
-        e1.Emit(222);
-
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-
-        GridGraphGenerator<int> grid;
-    }
-
-    return 0;
-}
-
-
-int main()
-{
-    Group group;
-
-    Group extGroup;
-
-    // Dynamic events
-    EventSource<int> s1{ group };
-    EventSource<int> s2{ group };
-    EventSource<int> s3{ extGroup };
-    //EventSource<int> s4{ extGroup };
-
-    EventSlot<int> slot{ group };
-
-    Observer eventObs{ PrintEvents<int>, slot };
-    //Observer extObs{ PrintEvents<int>, link1 };
-
-    //slot.Add(s1);
-    //slot.Add(s2);
-
-    group.DoTransaction([&]
-    {
-        s1.Emit(1);
-        s2.Emit(2);
-
-
-        slot.Add(s3);
-        slot.Add(s3);
-        slot.Add(s3);
-        slot.Add(s3);
-    });
-
-    s3.Emit(3);
-
-    std::this_thread::sleep_for(std::chrono::seconds(5));
-
-    Expected<int> x;
-
-    return 0;
-}
-
-
-
-
-
-
-
-
-int main2()
-{
-    Group group;
-
-    VarSignal<int> in{ group, 1 };
-    Signal<int> in2 = in;
-
-    GridGraphGenerator<int> generator;
-
-    generator.inputSignals.push_back(in2);
-
-    generator.widths.push_back(100);
-    generator.widths.push_back(1);
-
-    int updateCount = 0;
-
-    generator.function1 = [&] (int a) { ++updateCount; return a; };
-    generator.function2 = [&] (int a, int b) { ++updateCount; return a + b; };
-
-    generator.Generate(group);
-
-    updateCount = 0;
-
-    auto t0 = tbb::tick_count::now();
-    for (int i = 0; i < 10000; i++)
-	    in <<= 10 + i;
-    auto t1 = tbb::tick_count::now();
-
-    double d = (t1 - t0).seconds();
-    printf("updateCount %d\n", updateCount);
-    printf("Time %g\n", d);
-
-    return 0;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*
-
-int main7()
-{
-    Group group1;
-    Group group2;
-    Group group3;
-
-    VarSignal<int> x{ group1, 0 };
-    VarSignal<int> y{ group2, 0 };
-    VarSignal<int> z{ group3, 0 };
-
-    Signal<int> area{ Multiply<int>, x, y };
-    Signal<int> volume{ Multiply<int>, area, z };
-
-    Observer obs{ PrintAreaAndVolume, area, volume };
-
-    Signal<vector<int>> volumeHistory = Iterate<vector<int>>( vector<int>{ }, PushToVector, Monitor(volume));
-
-    x <<= 2;
-    y <<= 2;
-    z <<= 2;
-
-    group.DoTransaction([&]
-    {
-        x <<= 100;
-        y <<= 200;
-        z <<= 300;
-    });
-
-    obs.Cancel();
-
-    x <<= 42;
-
-    printf("History:\n");
-    for (auto t : volumeHistory.Value())
-        printf("%d ", t);
-    printf("\n");
-
-    return 0;
-}
-
-
-int main3()
-{
-    using namespace std;
-    using namespace react;
-
-    Group group1;
-    Group group2;
-
-    auto sig1 = VarSignal<int>( 10, group1 );
-
-    auto link1 = SignalLink<int>( sig1, group2 );
-    auto link2 = SignalLink<int>( sig1, group2 );
-
-    sig1.Set(10);
-
-    return 0;
-}
-
-*/
\ No newline at end of file

From eae1a8c20d67faa6182d684fa3eedf01543c0c9c Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:17:26 +0100
Subject: [PATCH 64/75] Updated readme.

---
 README.md | 185 +++++++-----------------------------------------------
 1 file changed, 24 insertions(+), 161 deletions(-)

diff --git a/README.md b/README.md
index 5c27b6bc..0654cddc 100644
--- a/README.md
+++ b/README.md
@@ -1,177 +1,40 @@
 # ![C++React](http://schlangster.github.io/cpp.react//media/logo_banner3.png)
 
-C++React is reactive programming library for C++11.
+C++React is reactive programming library for C++14 that enables declarative definition of data dependencies between state and event flows.
+Based on these definitions, propagation of changes is handled automatically.
 
-Generally speaking, it provides abstractions to handle change propagation and data processing for a push-based event model.
-A more practical description is that it enables coordinated, multi-layered - _and potentially parallel_ - execution of callbacks.
-All this happens implicitly, based on declarative definitions, with guarantees regarding
+Here's a simple example:
 
-- _update minimality_ - nothing is re-calculated or processed unnecessarily;
-- _glitch freedom_ - no transiently inconsistent data sets;
-- _thread safety_ - no data races for parallel execution by avoiding side effects.
-
-The core abstractions of the library are
-
-- _signals_, reactive variables that are automatically re-calculated when their dependencies change, and
-- _event streams_ as composable first class objects.
-
-Signals specifically deal with aspects of time-varying state, whereas event streams facilitate event processing in general.
-
-Additional features include
-
-- a publish/subscribe mechanism for callbacks with side effects;
-- a set of operations and algorithms to combine signals and events;
-- a domain model to encapsulate multiple reactive systems;
-- transactions to group related events, supporting both synchronous and asynchrounous execution.
-
-
-## Documentation
-
-[If you're interested in learning about C++React, have a look at its documentation.](http://schlangster.github.io/cpp.react/)
-
-
-## Using the library
-
-This library is a work-in-progress. It should not be considered release quality yet and its API might still change.
-It is, however, in a perfectly usable state and has already received a fair amount of testing and tuning.
-
-### Dependencies
-
-* [Intel TBB 4.2](https://www.threadingbuildingblocks.org/) (required)
-* [Google test framework](https://code.google.com/p/googletest/) (optional, to compile the unit tests)
-* [Boost 1.55.0 C++ Libraries](http://www.boost.org/) (optional, to include Reactor.h, which requires `boost::coroutine`)
-
-### Compiling
-
-C++React has been tested with the following compilers:
-
-* Visual Studio 2013.2
-* GCC 4.8.2
-* Clang 3.4
-
-To build with Visual Studio, use the pre-made solution found in `project/msvc/`.
-
-To build with GCC or Clang, use [CMake](http://www.cmake.org/):
-```
-mkdir build
-cd build
-cmake ..
-make
 ```
-
-For more details, refer to the [Build instructions](https://github.com/schlangster/cpp.react/wiki/Build-instructions).
-
-
-## Features by example
-
-### Signals
-
-Signals are self-updating reactive variables.
-They can be combined in expressions to create new signals, which are automatically re-calculated when their dependencies change.
-
-```C++
-using namespace std;
 using namespace react;
 
-// Defines a reactive domain that uses single-threaded, sequential updating
-REACTIVE_DOMAIN(D, sequential)
+void AddNumbers(int a, int b)  { return a + b; }
 
-// Defines aliases for types of the given domain,
-// e.g. using VarSignalT<X> = VarSignal<D,X>
-USING_REACTIVE_DOMAIN(D)
+// Two state variable objects. You can change their values manually.
+auto a = StateVar<int>::Create(0);
+auto b = StateVar<int>::Create(0);
 
-// Two reactive variables that can be manipulated imperatively
-// to input external changes
-VarSignalT<int> width  = MakeVar<D>(1);
-VarSignalT<int> height = MakeVar<D>(2);
+// Another state object. Its value is calculated automatically based on the given function and arguments.
+// If the arguments change, the value is re-calculated.
+auto sum = State<int>::Create(AddNumbers, a, b);
 
-// A signal that depends on width and height and multiplies their values
-SignalT<int> area = MakeSignal(
-    With(width, height),
-    [] (int w, int h) {
-        return w * h;
-    });
+// sum == 0
+a.Set(21);
+// sum == 21
+b.Set(21);
+// sum == 42
 ```
-Signal values can be accessed imperatively:
-```C++
-cout << "area: " << area.Value() << endl; // => area: 2
 
-// Width changed, so area is re-calculated automatically
-width.Set(10);
+The underlying system constructs a dependency graph to collect which values are affected by a change, and in which order they have to be re-calculated.
+This guarantees several properties:
+- _correctness_ - no updates are forgotten;
+- _consistency_ - no value is updated before all its incoming dependencies have been updated;
+- _efficiency_ - no value is re-calculated more than once per update cycle, and changes are only propagated along paths where a new value is different from the old one.
 
-cout << "area: " << area.Value() << endl; // => area: 20
-```
-
-Or, instead of using `Value()` to pull the new value, callback functions can be registered to receive notifications on a change:
-```C++
-Observe(area, [] (int newValue) {
-	cout << "area changed: " << newValue << endl;
-});
-```
-
-Overloaded operators for signal types allow to omit `MakeSignal` for a more concise syntax:
-```C++
-// Lift as reactive expression - equivalent to previous example
-SignalT<int> area = width * height;
-```
-
-### Event streams
-
-Unlike signals, event streams are not centered on changing state, but represent flows of discrete values. 
-They are first-class objects and can be merged, filtered, transformed or composed to more complex types:
-
-```C++
-using namespace std;
-using namespace react;
-
-REACTIVE_DOMAIN(D, sequential)
-USING_REACTIVE_DOMAIN(D)
-
-// Two event sources
-EventSourceT<Token> leftClick  = MakeEventSource<D>();
-EventSourceT<Token> rightClick = MakeEventSource<D>();
-
-// Merge both event streams
-EventsT<Token> anyClick = leftClick | rightClick;
-
-// React to events
-Observe(anyClick, [] (Token) {
-    cout << "clicked!" << endl;
-});
-```
-```
-leftClick.Emit(); // => clicked!
-rightClick.Emit(); // => clicked!
-```
-
-### Parallelism and concurrency
-
-When enabling it through the concurrency policy, updates are automatically parallelized:
-
-```C++
-REACTIVE_DOMAIN(D, parallel)
-
-VarSignalT<int> in = MakeVar<D>(0);
-
-SignalT<int> op1 = MakeSignal(in,
-    [] (int in) {
-        int result = doCostlyOperation1(in);
-        return result;
-    });
-
-SignalT<int> op2 = MakeSignal(in,
-    [] (int in) {
-        int result = doCostlyOperation2(in);
-        return result;
-    });
-
-// op1 and op2 can be re-calculated in parallel
-SignalT<int> out = op1 + op2;
-```
+The system also knows when it's safe to update values in parallel from multiple threads, and it can do live profiling to decide when that's worthwhile.
 
-## Acknowledgements
+## Development status
 
-The API of C++React has been inspired by the following two research papers:
+I'm currently in the process of rewriting the library more or less from scratch and many things are still broken or outdated.
 
-* [Deprecating the Observer Pattern with Scala.React](http://infoscience.epfl.ch/record/176887/files/DeprecatingObservers2012.pdf)
-* [REScala: Bridging Between Object-oriented and Functional Style in Reactive Applications](http://www.stg.tu-darmstadt.de/media/st/research/rescala_folder/REScala-Bridging-The-Gap-Between-Object-Oriented-And-Functional-Style-In-Reactive-Applications.pdf)
+[The old, but stable and documented version is still available in this branch.](https://github.com/schlangster/cpp.react/tree/legacy1)
\ No newline at end of file

From 5467003302e656c8fd983e619ccfe02a96007ffb Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Mon, 30 Oct 2017 22:18:58 +0100
Subject: [PATCH 65/75] Readme.

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0654cddc..f38e6486 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # ![C++React](http://schlangster.github.io/cpp.react//media/logo_banner3.png)
 
-C++React is reactive programming library for C++14 that enables declarative definition of data dependencies between state and event flows.
+C++React is reactive programming library for C++14. It enables the declarative definition of data dependencies between state and event flows.
 Based on these definitions, propagation of changes is handled automatically.
 
 Here's a simple example:

From 76be2a9438047148bcdd412eb7fde2148e3c57cf Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 1 Nov 2017 01:29:13 +0100
Subject: [PATCH 66/75] Added Ref<T> wrapper template. StateVars always contain
 elements by-value, but for State it might be convenient to use
 pointers/references, especially when dealing with class types. Use CreateRef
 for State<T> -> State<Ref<T>> binding. Semantically, it's the same as using
 State<T*>, but avoids the null check. The State<Ref<T>> changes when the
 referenced state changes.

---
 include/react/api.h                | 21 ++++++++++++++
 include/react/detail/state_nodes.h | 44 ++++++++++++++++++++++++------
 include/react/state.h              | 19 +++++++++----
 3 files changed, 71 insertions(+), 13 deletions(-)

diff --git a/include/react/api.h b/include/react/api.h
index 95ce57f6..2223cae8 100644
--- a/include/react/api.h
+++ b/include/react/api.h
@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include <type_traits>
 #include <vector>
 
 #include "react/detail/defs.h"
@@ -93,6 +94,26 @@ using EventValueSink = std::back_insert_iterator<std::vector<E>>;
 // Observer
 class Observer;
 
+// Ref
+template <typename T>
+using Ref = std::reference_wrapper<const T>;
+
+template <typename T>
+bool HasChanged(const T& a, const T& b)
+    { return !(a == b); }
+
+template <typename T>
+bool HasChanged(const Ref<T>& a, const Ref<T>& b)
+    { return true; }
+
+template <typename T, typename V>
+void ListInsert(T& list, V&& value)
+    { list.push_back(std::forward<V>(value)); }
+
+template <typename T, typename V>
+void MapInsert(T& map, V&& value)
+    { map.insert(std::forward<V>(value)); }
+
 /******************************************/ REACT_END /******************************************/
 
 #endif // REACT_TYPETRAITS_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/state_nodes.h b/include/react/detail/state_nodes.h
index aa8c8b85..dbc57fb3 100644
--- a/include/react/detail/state_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -171,22 +171,19 @@ class StateFuncNode : public StateNode<S>
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
-    {   
-        bool changed = false;
-
+    {
         S newValue = apply([this] (const auto& ... deps)
             { return this->func_(GetInternals(deps).Value() ...); }, depHolder_);
 
-        if (! (this->Value() == newValue))
+        if (HasChanged(this->Value(), newValue))
         {
             this->Value() = std::move(newValue);
-            changed = true;
-        }
-
-        if (changed)
             return UpdateResult::changed;
+        }
         else
+        {
             return UpdateResult::unchanged;
+        }
     }
 
 private:
@@ -439,6 +436,37 @@ class StateInternals
     std::shared_ptr<StateNode<S>> nodePtr_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// StateRefNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class StateRefNode : public StateNode<Ref<S>>
+{
+public:
+    StateRefNode(const Group& group, const State<S>& input) :
+        StateRefNode::StateNode( group, std::cref(GetInternals(input).Value()) ),
+        input_( input )
+    {
+        this->RegisterMe();
+        this->AttachToMe(GetInternals(input).GetNodeId());
+    }
+
+    ~StateRefNode()
+    {
+        this->DetachFromMe(GetInternals(input_).GetNodeId());
+        this->UnregisterMe();
+    }
+
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+    {
+        this->Value() = std::cref(GetInternals(input_).Value());
+        return UpdateResult::changed;
+    }
+
+private:
+    State<S> input_;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// SameGroupOrLink
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/state.h b/include/react/state.h
index d8235d37..40eeb574 100644
--- a/include/react/state.h
+++ b/include/react/state.h
@@ -202,10 +202,7 @@ class StateSlot : public State<S>
     StateSlot& operator=(StateSlot&&) = default;
 
     void Set(const State<S>& newInput)
-        { SetInput(newInput); }
-
-    void operator<<=(const State<S>& newInput)
-        { SetInput(newInput); }
+        { SetSlotInput(newInput); }
 
 protected:
     StateSlot(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
@@ -221,7 +218,7 @@ class StateSlot : public State<S>
         return std::make_shared<StateSlotNode<S>>(group, SameGroupOrLink(group, input));
     }
 
-    void SetInput(const State<S>& newInput)
+    void SetSlotInput(const State<S>& newInput)
     {
         using REACT_IMPL::NodeId;
         using REACT_IMPL::StateSlotNode;
@@ -282,6 +279,18 @@ class StateLink : public State<S>
     }
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// CreateRef
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+auto CreateRef(const State<S>& state) -> State<Ref<S>>
+{
+    using REACT_IMPL::StateRefNode;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<State<Ref<S>>, StateRefNode<S>>(state.GetGroup(), state);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// ObjectContext
 ///////////////////////////////////////////////////////////////////////////////////////////////////

From 90057e3e977d4d5d53a03bd5fb4c5f2c82b0e4e5 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 1 Nov 2017 01:30:02 +0100
Subject: [PATCH 67/75] Cleanup.

---
 include/react/detail/event_nodes.h | 14 ++++----------
 include/react/event.h              | 18 +++++++++---------
 2 files changed, 13 insertions(+), 19 deletions(-)

diff --git a/include/react/detail/event_nodes.h b/include/react/detail/event_nodes.h
index c918afec..fce5b4b1 100644
--- a/include/react/detail/event_nodes.h
+++ b/include/react/detail/event_nodes.h
@@ -45,12 +45,6 @@ template <typename E>
 class EventNode : public NodeBase
 {
 public:
-    EventNode(EventNode&&) = default;
-    EventNode& operator=(EventNode&&) = default;
-
-    EventNode(const EventNode&) = delete;
-    EventNode& operator=(const EventNode&) = delete;
-
     explicit EventNode(const Group& group) :
         EventNode::NodeBase( group )
     { }
@@ -161,7 +155,7 @@ class EventSlotNode : public EventNode<E>
 
     ~EventSlotNode()
     {
-        RemoveAllInputs();
+        RemoveAllSlotInputs();
         this->DetachFromMe(inputNodeId_);
 
         this->UnregisterMe();
@@ -182,7 +176,7 @@ class EventSlotNode : public EventNode<E>
             return UpdateResult::unchanged;
     }
 
-    void AddInput(const Event<E>& input)
+    void AddSlotInput(const Event<E>& input)
     {
         auto it = std::find(inputs_.begin(), inputs_.end(), input);
         if (it == inputs_.end())
@@ -192,7 +186,7 @@ class EventSlotNode : public EventNode<E>
         }
     }
 
-    void RemoveInput(const Event<E>& input)
+    void RemoveSlotInput(const Event<E>& input)
     {
         auto it = std::find(inputs_.begin(), inputs_.end(), input);
         if (it != inputs_.end())
@@ -202,7 +196,7 @@ class EventSlotNode : public EventNode<E>
         }
     }
 
-    void RemoveAllInputs()
+    void RemoveAllSlotInputs()
     {
         for (const auto& e : inputs_)
             this->DetachFromMe(GetInternals(e).GetNodeId());
diff --git a/include/react/event.h b/include/react/event.h
index aeaaa6f6..8dd05d46 100644
--- a/include/react/event.h
+++ b/include/react/event.h
@@ -192,13 +192,13 @@ class EventSlot : public Event<E>
     EventSlot& operator=(EventSlot&&) = default;
 
     void Add(const Event<E>& input)
-        { AddInput(input); }
+        { AddSlotInput(input); }
 
     void Remove(const Event<E>& input)
-        { RemoveInput(input); }
+        { RemoveSlotInput(input); }
 
     void RemoveAll()
-        { RemoveAllInputs(); }
+        { RemoveAllSlotInputs(); }
 
 protected:
     EventSlot(std::shared_ptr<REACT_IMPL::EventNode<E>>&& nodePtr) :
@@ -212,7 +212,7 @@ class EventSlot : public Event<E>
         return std::make_shared<EventSlotNode<E>>(group);
     }
 
-    void AddInput(const Event<E>& input)
+    void AddSlotInput(const Event<E>& input)
     {
         using REACT_IMPL::NodeId;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
@@ -222,10 +222,10 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->AddInput(SameGroupOrLink(GetGroup(), input)); });
+        graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->AddSlotInput(SameGroupOrLink(GetGroup(), input)); });
     }
 
-    void RemoveInput(const Event<E>& input)
+    void RemoveSlotInput(const Event<E>& input)
     {
         using REACT_IMPL::NodeId;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
@@ -235,10 +235,10 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->RemoveInput(SameGroupOrLink(GetGroup(), input)); });
+        graphPtr->PushInput(nodeId, [this, castedPtr, &input] { castedPtr->RemoveSlotInput(SameGroupOrLink(GetGroup(), input)); });
     }
 
-    void RemoveAllInputs()
+    void RemoveAllSlotInputs()
     {
         using REACT_IMPL::NodeId;
         using SlotNodeType = REACT_IMPL::EventSlotNode<E>;
@@ -248,7 +248,7 @@ class EventSlot : public Event<E>
         NodeId nodeId = castedPtr->GetInputNodeId();
         auto& graphPtr = GetInternals(this->GetGroup()).GetGraphPtr();
 
-        graphPtr->PushInput(nodeId, [castedPtr] { castedPtr->RemoveAllInputs(); });
+        graphPtr->PushInput(nodeId, [castedPtr] { castedPtr->RemoveAllSlotInputs(); });
     }
 };
 

From 8e1f42fe37558d8ad224d6bdc8e2f6117e36aee2 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Wed, 1 Nov 2017 01:32:28 +0100
Subject: [PATCH 68/75] WIP: Flattening for nested state.

---
 examples/src/BasicAlgorithms.cpp       | 120 ++++++++++++-
 include/react/algorithm.h              |  84 +++++++++
 include/react/detail/algorithm_nodes.h | 236 +++++++++++++++++++++++++
 include/react/detail/graph_interface.h |   3 +-
 4 files changed, 440 insertions(+), 3 deletions(-)

diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index d6f8aced..b2fa8b96 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -340,17 +340,133 @@ namespace example6
     }
 }
 
+
+using namespace react;
+
+
+template <typename T>
+class MyContainer { };
+
+template <typename C>
+struct Flattened : public C
+{
+    using C::C;
+
+    Flattened(const C& base) :
+        C( base )
+    { }
+
+    Flattened(const C& base, int m) :
+        C( base ),
+        mode( m )
+    { }
+
+    template <typename T>
+    T* Flatten(State<T>& signal)
+    {
+        if (mode == 1)
+        {
+            memberIds_.push_back(GetInternals(signal).GetNodeId());
+        }
+        
+        return &GetInternals(signal).Value();
+    }
+
+public:
+    int mode = 0;
+    std::vector<REACT_IMPL::NodeId> memberIds_;
+};
+
+Group g;
+
+struct MyClass
+{
+    StateVar<int> a = StateVar<int>::Create(g, 10);
+    StateVar<int> b = StateVar<int>::Create(g, 20);
+
+    int hello = 12435;
+
+    bool operator==(const MyClass& other)
+        { return hello == other.hello; }
+
+    struct Flat;
+};
+
+struct MyClass::Flat : public Flattened<MyClass>
+{
+    using Flattened::Flattened;
+
+    int* a = this->Flatten(MyClass::a);
+    int* b = this->Flatten(MyClass::b);
+};
+
+
+void test1()
+{
+    using namespace react;
+
+    /*StateVar<int> x;
+    State<int> y;
+    State<int> z;
+
+    State<std::vector<State<int>>>   list;
+    State<std::map<int, State<int>>> map;
+
+    State<std::vector<int>> flatlist = FlattenList(list);
+    State<std::map<int, int>> flatmap = FlattenMap(map);
+
+    MyClass cls1;
+    MyClass::Flat cls2(cls1);
+
+    StateVar<State<int>> sig;
+
+    Flatten(g, sig);*/
+
+    StateVar<MyClass> st = StateVar<MyClass>::Create(g);
+
+    State<Ref<MyClass>> ref = CreateRef(st);
+
+    auto obs2 = Observer::Create([] (const MyClass& obj)
+        {
+            printf("aa %d\n", obj.hello);
+        }, ref);
+
+    auto flat = FlattenObject(st);
+
+    auto flat2 = FlattenObject(ref);
+
+    auto obs = Observer::Create([] (const MyClass::Flat& obj)
+        {
+            int x = *obj.a;
+            int y = *obj.b;
+            printf("%d\n", x);
+            printf("%d\n", y);
+        }, flat2);
+
+
+    GetInternals(st).Value().a.Set(999);
+
+    MyClass a2{ };
+    a2.hello = 3333;
+
+    st.Set(a2);
+    st.Set(a2);
+
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Run examples
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int main()
 {
-    example1::Run();
+    /*example1::Run();
     example2::Run();
     example3::Run();
     example4::Run();
     example5::Run();
-    example6::Run();
+    example6::Run();*/
+
+    test1();
 
     return 0;
 }
\ No newline at end of file
diff --git a/include/react/algorithm.h b/include/react/algorithm.h
index 075f3d3c..1d95bbce 100644
--- a/include/react/algorithm.h
+++ b/include/react/algorithm.h
@@ -169,6 +169,90 @@ template <typename S, typename E>
 auto Pulse(const State<S>& state, const Event<E>& evnt) -> Event<S>
     { return Pulse(state.GetGroup(), state, evnt); }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Flatten
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+auto Flatten(const Group& group, const State<State<S>>& state) -> State<S>
+{
+    using REACT_IMPL::FlattenStateNode;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<State<S>, FlattenStateNode<S>>(group, SameGroupOrLink(group, state));
+}
+
+template <typename S>
+auto Flatten(const State<State<S>>& state) -> State<S>
+    { return Flatten(state.GetGroup(), state); }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenList
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <template <typename ...> class TList, typename V, typename ... TParams>
+auto FlattenList(const Group& group, const State<TList<State<V>, TParams ...>>& list) -> State<TList<V>>
+{
+    using REACT_IMPL::FlattenStateListNode;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<State<TList<V>>, FlattenStateListNode<TList, V, TParams ...>>(
+        group, SameGroupOrLink(group, list));
+}
+
+template <template <typename ...> class TList, typename V, typename ... TParams>
+auto FlattenList(const State<TList<State<V>, TParams ...>>& list) -> State<TList<V>>
+    { return FlattenList(list.GetGroup(), list); }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenMap
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <template <typename ...> class TMap, typename K, typename V, typename ... TParams>
+auto FlattenMap(const Group& group, const State<TMap<K, State<V>, TParams ...>>& map) -> State<TMap<K, V>>
+{
+    using REACT_IMPL::FlattenStateMapNode;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<State<TMap<K, V>>, FlattenStateMapNode<TMap, K, V, TParams ...>>(
+        group, SameGroupOrLink(group, map));
+}
+
+template <template <typename ...> class TMap, typename K, typename V, typename ... TParams>
+auto FlattenMap(const State<TMap<K, State<V>, TParams ...>>& map) -> State<TMap<K, V>>
+    { return FlattenMap(map.GetGroup(), map); }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenObject
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T, typename TFlat = typename T::Flat>
+auto FlattenObject(const Group& group, const State<T>& obj) -> State<TFlat>
+{
+    using REACT_IMPL::FlattenObjectNode;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<State<TFlat>, FlattenObjectNode<T, TFlat>>(group, obj);
+}
+
+template <typename T, typename TFlat = typename T::Flat>
+auto FlattenObject(const State<T>& obj) -> State<TFlat>
+    { return FlattenObject(obj.GetGroup(), obj); }
+
+template <typename T, typename TFlat = typename T::Flat>
+auto FlattenObject(const Group& group, const State<Ref<T>>& obj) -> State<TFlat>
+{
+    using REACT_IMPL::FlattenObjectNode;
+    using REACT_IMPL::SameGroupOrLink;
+    using REACT_IMPL::CreateWrappedNode;
+
+    return CreateWrappedNode<State<TFlat>, FlattenObjectNode<Ref<T>, TFlat>>(group, obj);
+}
+
+template <typename T, typename TFlat = typename T::Flat>
+auto FlattenObject(const State<Ref<T>>& obj) -> State<TFlat>
+    { return FlattenObject(obj.GetGroup(), obj); }
+
 /******************************************/ REACT_END /******************************************/
 
 #endif // REACT_ALGORITHM_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/algorithm_nodes.h b/include/react/detail/algorithm_nodes.h
index 968080d5..eb5f221d 100644
--- a/include/react/detail/algorithm_nodes.h
+++ b/include/react/detail/algorithm_nodes.h
@@ -11,6 +11,7 @@
 
 #include "react/detail/defs.h"
 
+#include <algorithm>
 #include <memory>
 #include <utility>
 
@@ -371,6 +372,241 @@ class PulseNode : public EventNode<S>
     Event<E>    trigger_;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenStateNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename S>
+class FlattenStateNode : public StateNode<S>
+{
+public:
+    FlattenStateNode(const Group& group, const State<State<S>>& outer) :
+        FlattenStateNode::StateNode( group, GetInternals(GetInternals(outer).Value()).Value() ),
+        outer_( outer ),
+        inner_( GetInternals(outer).Value() )
+    {
+        this->RegisterMe();
+        this->AttachToMe(GetInternals(outer_).GetNodeId());
+        this->AttachToMe(GetInternals(inner_).GetNodeId());
+    }
+
+    ~FlattenStateNode()
+    {
+        this->DetachFromMe(GetInternals(inner_).GetNodeId());
+        this->DetachFromMe(GetInternals(outer_).GetNodeId());
+        this->UnregisterMe();
+    }
+
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+    {
+        const State<S>& newInner = GetInternals(outer_).Value();
+
+        // Check if there's a new inner node.
+        if (! (newInner == inner_))
+        {
+            this->DetachFromMe(GetInternals(inner_).GetNodeId());
+            this->AttachToMe(GetInternals(newInner).GetNodeId());
+            inner_ = newInner;
+            return UpdateResult::shifted;
+        }
+
+        const S& newValue = GetInternals(inner_).Value();
+
+        if (HasChanged(newValue, this->Value()))
+        {
+            this->Value() = newValue;
+            return UpdateResult::changed;
+        }
+
+        return UpdateResult::unchanged;
+    }
+
+private:
+    State<State<S>> outer_;
+    State<S>        inner_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenStateListNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <template <typename ...> class TList, typename V, typename ... TParams>
+class FlattenStateListNode : public StateNode<TList<V>>
+{
+public:
+    using InputListType = TList<State<V>, TParams ...>;
+    using FlatListType = TList<V>;
+
+    FlattenStateListNode(const Group& group, const State<InputListType>& outer) :
+        FlattenStateListNode::StateNode( group, MakeFlatList(GetInternals(outer).Value()) ),
+        outer_( outer ),
+        inner_( GetInternals(outer).Value() )
+    {
+        this->RegisterMe();
+        this->AttachToMe(GetInternals(outer_).GetNodeId());
+
+        for (const State<V>& state : inner_)
+            this->AttachToMe(GetInternals(state).GetNodeId());
+    }
+
+    ~FlattenStateListNode()
+    {
+        for (const State<V>& state : inner_)
+            this->DetachFromMe(GetInternals(state).GetNodeId());
+
+        this->DetachFromMe(GetInternals(outer_).GetNodeId());
+        this->UnregisterMe();
+    }
+
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+    {
+        const InputListType& newInner = GetInternals(outer_).Value();
+
+        // Check if there's a new inner node.
+        if (! (std::equal(begin(newInner), end(newInner), begin(inner_), end(inner_))))
+        {
+            for (const State<V>& state : inner_)
+                this->DetachFromMe(GetInternals(state).GetNodeId());
+            for (const State<V>& state : newInner)
+                this->AttachToMe(GetInternals(state).GetNodeId());
+
+            inner_ = newInner;
+            return UpdateResult::shifted;
+        }
+
+        FlatListType newValue = MakeFlatList(inner_);
+        const FlatListType& curValue = this->Value();
+
+        if (! (std::equal(begin(newValue), end(newValue), begin(curValue), end(curValue), [] (const auto& a, const auto& b)
+            { return !HasChanged(a, b); })))
+        {
+            this->Value() = std::move(newValue);
+            return UpdateResult::changed;
+        }
+
+        return UpdateResult::unchanged;
+    }
+
+private:
+    static FlatListType MakeFlatList(const InputListType& list)
+    {
+        FlatListType res;
+        for (const State<V>& state : list)
+            ListInsert(res, GetInternals(state).Value());
+        return res;
+    }
+
+    State<InputListType>    outer_;
+    InputListType           inner_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenStateListNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <template <typename ...> class TMap, typename K, typename V, typename ... TParams>
+class FlattenStateMapNode : public StateNode<TMap<K, V>>
+{
+public:
+    using InputMapType = TMap<K, State<V>, TParams ...>;
+    using FlatMapType = TMap<K, V>;
+
+    FlattenStateMapNode(const Group& group, const State<InputMapType>& outer) :
+        FlattenStateMapNode::StateNode( group, MakeFlatMap(GetInternals(outer).Value()) ),
+        outer_( outer ),
+        inner_( GetInternals(outer).Value() )
+    {
+        this->RegisterMe();
+        this->AttachToMe(GetInternals(outer_).GetNodeId());
+
+        for (const auto& entry : inner_)
+            this->AttachToMe(GetInternals(entry.second).GetNodeId());
+    }
+
+    ~FlattenStateMapNode()
+    {
+        for (const auto& entry : inner_)
+            this->DetachFromMe(GetInternals(entry.second).GetNodeId());
+
+        this->DetachFromMe(GetInternals(outer_).GetNodeId());
+        this->UnregisterMe();
+    }
+
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+    {
+        const InputMapType& newInner = GetInternals(outer_).Value();
+
+        // Check if there's a new inner node.
+        if (! (std::equal(begin(newInner), end(newInner), begin(inner_), end(inner_))))
+        {
+            for (const auto& entry : inner_)
+                this->DetachFromMe(GetInternals(entry.second).GetNodeId());
+            for (const auto& entry : newInner)
+                this->AttachToMe(GetInternals(entry.second).GetNodeId());
+
+            inner_ = newInner;
+            return UpdateResult::shifted;
+        }
+
+        FlatMapType newValue = MakeFlatMap(inner_);
+        const FlatMapType& curValue = this->Value();
+
+        if (! (std::equal(begin(newValue), end(newValue), begin(curValue), end(curValue), [] (const auto& a, const auto& b)
+            { return !HasChanged(a.first, b.first) && !HasChanged(a.second, b.second); })))
+        {
+            this->Value() = std::move(newValue);
+            return UpdateResult::changed;
+        }
+
+        return UpdateResult::unchanged;
+    }
+
+private:
+    static FlatMapType MakeFlatMap(const InputMapType& map)
+    {
+        FlatMapType res;
+        for (const auto& entry : map)
+            MapInsert(res, typename FlatMapType::value_type{ entry.first, GetInternals(entry.second).Value() });
+        return res;
+    }
+
+    State<InputMapType>    outer_;
+    InputMapType           inner_;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// FlattenObjectNode
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename T, typename TFlat>
+class FlattenObjectNode : public StateNode<TFlat>
+{
+public:
+    FlattenObjectNode(const Group& group, const State<T>& obj) :
+        StateNode::StateNode( in_place, group, GetInternals(obj).Value(), 1 )
+    {
+        this->RegisterMe();
+
+        for (NodeId id : Value().memberIds_)
+        {
+            this->AttachToMe(id);
+        }
+
+        Value().mode = 0;
+    }
+
+    ~FlattenObjectNode()
+    {
+        for (NodeId id :  Value().memberIds_)
+            this->DetachFromMe(id);
+
+        this->UnregisterMe();
+    }
+
+    virtual UpdateResult Update(TurnId turnId) noexcept override
+    {
+        return UpdateResult::changed;
+    }
+
+private:
+};
+
 /****************************************/ REACT_IMPL_END /***************************************/
 
 #endif // REACT_DETAIL_ALGORITHM_NODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph_interface.h b/include/react/detail/graph_interface.h
index 8d0997b3..3faffa0f 100644
--- a/include/react/detail/graph_interface.h
+++ b/include/react/detail/graph_interface.h
@@ -35,7 +35,8 @@ static LinkId invalid_link_id = (std::numeric_limits<size_t>::max)();
 enum class UpdateResult
 {
     unchanged,
-    changed
+    changed,
+    shifted
 };
 
 enum class NodeCategory

From a2c3041df5a8663d469d4f8efd2d7643eea3fe01 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 2 Nov 2017 00:21:19 +0100
Subject: [PATCH 69/75] Support nested transactions. Support node shifting.

---
 include/react/detail/graph_impl.h |  8 ++++----
 src/detail/graph_impl.cpp         | 21 ++++++++++++++++++---
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/include/react/detail/graph_impl.h b/include/react/detail/graph_impl.h
index 14391d14..73110aaf 100644
--- a/include/react/detail/graph_impl.h
+++ b/include/react/detail/graph_impl.h
@@ -180,7 +180,7 @@ class ReactGraph
 
     LinkCache linkCache_;
 
-    bool isTransactionActive_ = false;
+    int  transactionLevel_ = 0;
     bool allowLinkedTransactionMerging_ = false;
 };
 
@@ -195,7 +195,7 @@ void ReactGraph::PushInput(NodeId nodeId, F&& inputCallback)
     
     changedInputs_.push_back(nodeId);
 
-    if (!isTransactionActive_)
+    if (transactionLevel_ == 0)
         Propagate();
 }
 
@@ -203,9 +203,9 @@ template <typename F>
 void ReactGraph::DoTransaction(F&& transactionCallback)
 {
     // Transaction callback may add multiple inputs.
-    isTransactionActive_ = true;
+    ++transactionLevel_;
     std::forward<F>(transactionCallback)();
-    isTransactionActive_ = false;
+    --transactionLevel_;
 
     Propagate();
 }
diff --git a/src/detail/graph_impl.cpp b/src/detail/graph_impl.cpp
index fb44a252..5f604527 100644
--- a/src/detail/graph_impl.cpp
+++ b/src/detail/graph_impl.cpp
@@ -72,7 +72,9 @@ void ReactGraph::Propagate()
         auto& node = nodeData_[nodeId];
         auto* nodePtr = node.nodePtr;
 
-        if (nodePtr->Update(0u) == UpdateResult::changed)
+        UpdateResult res = nodePtr->Update(0u);
+
+        if (res == UpdateResult::changed)
         {
             changedNodes_.push_back(nodePtr);
             ScheduleSuccessors(node);
@@ -87,10 +89,12 @@ void ReactGraph::Propagate()
             auto& node = nodeData_[nodeId];
             auto* nodePtr = node.nodePtr;
 
+            // A predecessor of this node has shifted to a lower level?
             if (node.level < node.newLevel)
             {
-                // Re-schedule this node
+                // Re-schedule this node.
                 node.level = node.newLevel;
+
                 RecalculateSuccessorLevels(node);
                 scheduledNodes_.Push(nodeId, node.level);
                 continue;
@@ -103,7 +107,18 @@ void ReactGraph::Propagate()
                 continue;
             }
 
-            if (nodePtr->Update(0u) == UpdateResult::changed)
+            UpdateResult res = nodePtr->Update(0u);
+
+            // Topology changed?
+            if (res == UpdateResult::shifted)
+            {
+                // Re-schedule this node.
+                RecalculateSuccessorLevels(node);
+                scheduledNodes_.Push(nodeId, node.level);
+                continue;
+            }
+            
+            if (res == UpdateResult::changed)
             {
                 changedNodes_.push_back(nodePtr);
                 ScheduleSuccessors(node);

From 942582db5227e29a4bb1f0cc90c1de1133c189cf Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 2 Nov 2017 00:29:25 +0100
Subject: [PATCH 70/75] Implemented FlattenObjectNode. Removed ObjectState.
 FlattenObject does the same but is more flexible. Cleanup.

---
 include/react/algorithm.h              |  41 ++++++++++
 include/react/api.h                    |  14 ++--
 include/react/detail/algorithm_nodes.h |  39 +++++++---
 include/react/detail/state_nodes.h     |  71 +-----------------
 include/react/state.h                  | 100 +------------------------
 tests/src/state_tests.cpp              |  54 -------------
 6 files changed, 82 insertions(+), 237 deletions(-)

diff --git a/include/react/algorithm.h b/include/react/algorithm.h
index 1d95bbce..2390487d 100644
--- a/include/react/algorithm.h
+++ b/include/react/algorithm.h
@@ -222,6 +222,47 @@ template <template <typename ...> class TMap, typename K, typename V, typename .
 auto FlattenMap(const State<TMap<K, State<V>, TParams ...>>& map) -> State<TMap<K, V>>
     { return FlattenMap(map.GetGroup(), map); }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// Flattened
+///////////////////////////////////////////////////////////////////////////////////////////////////
+template <typename C>
+class Flattened : public C
+{
+public:
+    using C::C;
+
+    Flattened(const C& base) :
+        C( base )
+    { }
+
+    Flattened(const C& base, REACT_IMPL::FlattenedInitTag) :
+        C( base ),
+        initMode_( true )
+    { }
+
+    Flattened(const C& base, REACT_IMPL::FlattenedInitTag, std::vector<REACT_IMPL::NodeId>&& emptyMemberIds) :
+        C( base ),
+        initMode_( true ),
+        memberIds_( std::move(emptyMemberIds) ) // This will be empty, but has pre-allocated storage. It's a tweak.
+    { }
+
+    template <typename T>
+    Ref<T> Flatten(State<T>& signal)
+    {
+        if (initMode_)
+            memberIds_.push_back(GetInternals(signal).GetNodeId());
+        
+        return GetInternals(signal).Value();
+    }
+
+private:
+    bool initMode_ = false;
+    std::vector<REACT_IMPL::NodeId> memberIds_;
+
+    template <typename T, typename TFlat>
+    friend class impl::FlattenObjectNode;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenObject
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/api.h b/include/react/api.h
index 2223cae8..1fea1251 100644
--- a/include/react/api.h
+++ b/include/react/api.h
@@ -53,6 +53,10 @@ static constexpr InPlaceTag in_place = InPlaceTag::value;
 // Group
 class Group;
 
+// Ref
+template <typename T>
+using Ref = std::reference_wrapper<const T>;
+
 // State
 template <typename S>
 class State;
@@ -66,12 +70,8 @@ class StateSlot;
 template <typename S>
 class StateLink;
 
-// Object state
 template <typename S>
-class ObjectContext;
-
-template <typename T>
-class ObjectState;
+using StateRef = State<Ref<S>>;
 
 // Event
 enum class Token;
@@ -94,10 +94,6 @@ using EventValueSink = std::back_insert_iterator<std::vector<E>>;
 // Observer
 class Observer;
 
-// Ref
-template <typename T>
-using Ref = std::reference_wrapper<const T>;
-
 template <typename T>
 bool HasChanged(const T& a, const T& b)
     { return !(a == b); }
diff --git a/include/react/detail/algorithm_nodes.h b/include/react/detail/algorithm_nodes.h
index eb5f221d..ec091f0c 100644
--- a/include/react/detail/algorithm_nodes.h
+++ b/include/react/detail/algorithm_nodes.h
@@ -571,6 +571,8 @@ class FlattenStateMapNode : public StateNode<TMap<K, V>>
     InputMapType           inner_;
 };
 
+struct FlattenedInitTag { };
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenObjectNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -579,32 +581,51 @@ class FlattenObjectNode : public StateNode<TFlat>
 {
 public:
     FlattenObjectNode(const Group& group, const State<T>& obj) :
-        StateNode::StateNode( in_place, group, GetInternals(obj).Value(), 1 )
+        StateNode::StateNode( in_place, group, GetInternals(obj).Value(), FlattenedInitTag{ } ),
+        obj_( obj )
     {
         this->RegisterMe();
+        this->AttachToMe(GetInternals(obj).GetNodeId());
 
-        for (NodeId id : Value().memberIds_)
-        {
-            this->AttachToMe(id);
-        }
+        for (NodeId nodeId : Value().memberIds_)
+            this->AttachToMe(nodeId);
 
-        Value().mode = 0;
+        this->Value().initMode_ = false;
     }
 
     ~FlattenObjectNode()
     {
-        for (NodeId id :  Value().memberIds_)
-            this->DetachFromMe(id);
+        for (NodeId nodeId :  Value().memberIds_)
+            this->DetachFromMe(nodeId);
 
+        this->DetachFromMe(GetInternals(obj_).GetNodeId());
         this->UnregisterMe();
     }
 
     virtual UpdateResult Update(TurnId turnId) noexcept override
     {
+        const T& newValue = GetInternals(obj_).Value();
+
+        if (HasChanged(newValue, static_cast<const T&>(this->Value())))
+        {
+            for (NodeId nodeId : this->Value().memberIds_)
+                this->DetachFromMe(nodeId);
+
+            // Steal array from old value for new value so we don't have to re-allocate.
+            // The old value will freed after the assignment.
+            this->Value().memberIds_.clear();
+            this->Value() = TFlat { newValue, FlattenedInitTag{ }, std::move(this->Value().memberIds_) };
+
+            for (NodeId nodeId : this->Value().memberIds_)
+                this->AttachToMe(nodeId);
+
+            return UpdateResult::shifted;
+        }
+
         return UpdateResult::changed;
     }
-
 private:
+    State<T> obj_;
 };
 
 /****************************************/ REACT_IMPL_END /***************************************/
diff --git a/include/react/detail/state_nodes.h b/include/react/detail/state_nodes.h
index dbc57fb3..9c5e6132 100644
--- a/include/react/detail/state_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -87,7 +87,7 @@ class StateVarNode : public StateNode<S>
         {
             isInputAdded_ = false;
 
-            if (! (this->Value() == newValue_))
+            if (HasChanged(this->Value(), newValue_))
             {
                 this->Value() = std::move(newValue_);
                 return UpdateResult::changed;
@@ -310,14 +310,12 @@ class StateLinkNode : public StateNode<S>
             if (auto p = parent.lock())
             {
                 auto* rawPtr = p->GetGraphPtr().get();
-                output[rawPtr].push_back(
-                    [storedParent = std::move(p), storedValue = GetInternals(p->dep_).Value()] () mutable -> void
+                output[rawPtr].push_back([storedParent = std::move(p), storedValue = GetInternals(p->dep_).Value()] () mutable -> void
                     {
                         NodeId nodeId = storedParent->GetNodeId();
                         auto& graphPtr = storedParent->GetGraphPtr();
 
-                        graphPtr->PushInput(nodeId,
-                            [&storedParent, &storedValue]
+                        graphPtr->PushInput(nodeId, [&storedParent, &storedValue]
                             {
                                 storedParent->SetValue(std::move(storedValue));
                             });
@@ -335,69 +333,6 @@ class StateLinkNode : public StateNode<S>
     VirtualOutputNode linkOutput_;
 };
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObjectStateNode
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class ObjectStateNode : public StateNode<ObjectContext<S>>
-{
-public:
-    ObjectStateNode(const Group& group, S&& obj, const std::initializer_list<NodeId>& memberIds) :
-        ObjectStateNode::StateNode( group, &object_ ),
-        object_( std::move(obj) )
-    {
-        this->RegisterMe();
-
-        if (memberIds.size() == 0)
-        {
-            apply([this] (const auto& ... members)
-                {
-                    REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId()));
-                    REACT_EXPAND_PACK(this->AttachToMe(GetInternals(members).GetNodeId()));
-                }, object_.GetReactiveMembers());
-        }
-        else
-        {
-            memberIds_.reserve(memberIds.size());
-
-            for (NodeId id : memberIds)
-            {
-                memberIds_.push_back(id);
-                this->AttachToMe(id);
-            }
-        }
-    }
-
-    template <typename ... Us>
-    ObjectStateNode(InPlaceTag, const Group& group, Us&& ... args) :
-        ObjectStateNode::StateNode( group, &object_ ),
-        object_( group, std::forward<Us>(args) ... )
-    {
-        this->RegisterMe();
-
-        apply([this] (const auto& ... members)
-            { REACT_EXPAND_PACK(memberIds_.push_back(GetInternals(members).GetNodeId())); }, object_.GetReactiveMembers());
-    }
-
-    ~ObjectStateNode()
-    {
-        // TODO: This must happen inside of the node
-        for (NodeId id : memberIds_)
-            this->DetachFromMe(id);
-
-        this->UnregisterMe();
-    }
-
-    virtual UpdateResult Update(TurnId turnId) noexcept override
-    {
-        return UpdateResult::changed;
-    }
-
-private:
-    S object_;
-    std::vector<NodeId> memberIds_;
-};
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// StateInternals
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/state.h b/include/react/state.h
index 40eeb574..d7942cce 100644
--- a/include/react/state.h
+++ b/include/react/state.h
@@ -130,6 +130,9 @@ class StateVar : public State<S>
     friend bool operator!=(const StateVar<S>& a, StateVar<S>& b)
         { return !(a == b); }
 
+    S* operator->()
+        { return &this->Value(); }
+
 protected:
     StateVar(std::shared_ptr<REACT_IMPL::StateNode<S>>&& nodePtr) :
         StateVar::State( std::move(nodePtr) )
@@ -291,103 +294,6 @@ auto CreateRef(const State<S>& state) -> State<Ref<S>>
     return CreateWrappedNode<State<Ref<S>>, StateRefNode<S>>(state.GetGroup(), state);
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObjectContext
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class ObjectContext
-{
-public:
-    ObjectContext() = default;
-
-    ObjectContext(const ObjectContext&) = default;
-    ObjectContext& operator=(const ObjectContext&) = default;
-
-    ObjectContext(ObjectContext&&) = default;
-    ObjectContext& operator=(ObjectContext&&) = default;
-
-    S& GetObject()
-        { return *objectPtr_; }
-
-    const S& GetObject() const
-        { return *objectPtr_; }
-
-    template <typename U>
-    const U& Get(const State<U>& member) const
-        { return GetInternals(member).Value(); }
-
-    template <typename U>
-    const EventValueList<U>& Get(const Event<U>& member) const
-        { return GetInternals(member).Events(); }
-
-private:
-    template <typename ... Us>
-    explicit ObjectContext(S* objectPtr) :
-        objectPtr_( objectPtr )
-    { }
-
-    S* objectPtr_;
-
-    template <typename U>
-    friend class impl::StateNode;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-/// ObjectState
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-class ObjectState : public State<ObjectContext<S>>
-{
-public:
-    // Construct with group
-    template <typename ... Us>
-    static ObjectState Create(const Group& group, S&& obj, const Us& ... members)
-    {
-        using REACT_IMPL::NodeId;
-
-        std::initializer_list<NodeId> memberIds = { GetInternals(members).GetNodeId() ... };
-
-        return CreateObjectStateNode(group, std::move(obj), memberIds);
-    }
-
-    template <typename ... Us>
-    static ObjectState Create(InPlaceTag, const Group& group, Us&& ... args)
-        { return CreateObjectStateNode(in_place, group, std::forward<Us>(args) ...); }
-
-    ObjectState() = default;
-
-    ObjectState(const ObjectState&) = default;
-    ObjectState& operator=(const ObjectState&) = default;
-
-    ObjectState(ObjectState&&) = default;
-    ObjectState& operator=(ObjectState&&) = default;
-
-    S* operator->()
-        { return &this->Value().GetObject(); }
-
-protected:
-    ObjectState(std::shared_ptr<REACT_IMPL::StateNode<ObjectContext<S>>>&& nodePtr) :
-        ObjectState::State( std::move(nodePtr) )
-    { }
-
-private:
-    static auto CreateObjectStateNode(const Group& group, S&& obj, const std::initializer_list<REACT_IMPL::NodeId>& memberIds) -> decltype(auto)
-    {
-        using REACT_IMPL::ObjectStateNode;
-
-        return std::make_shared<ObjectStateNode<S>>(group, std::move(obj), memberIds);
-    }
-
-    template <typename ... Us>
-    static auto CreateObjectStateNode(InPlaceTag, const Group& group, Us&& ... args) -> decltype(auto)
-    {
-        using REACT_IMPL::ObjectStateNode;
-        using REACT_IMPL::SameGroupOrLink;
-
-        return std::make_shared<ObjectStateNode<S>>(in_place, group, std::forward<Us>(args) ...);
-    }
-};
-
 /******************************************/ REACT_END /******************************************/
 
 #endif // REACT_STATE_H_INCLUDED
\ No newline at end of file
diff --git a/tests/src/state_tests.cpp b/tests/src/state_tests.cpp
index ab9d70b8..5018fe39 100644
--- a/tests/src/state_tests.cpp
+++ b/tests/src/state_tests.cpp
@@ -424,57 +424,3 @@ TEST(StateTest, Modify3)
 
     ASSERT_EQ(turns, 2);
 }
-
-class Widget
-{
-public:
-    StateVar<int> color;
-
-    StateVar<int> width;
-    StateVar<int> height;
-
-    auto GetReactiveMembers() const -> decltype(auto)
-        { return std::tie(color, width, height); }
-
-    Widget(const Group& group)
-    {
-        color  = StateVar<int>::Create(group, 0);
-        width  = StateVar<int>::Create(group, 0);
-        height = StateVar<int>::Create(group, 0);
-    }
-
-    Widget(const Group& group, int value)
-    {
-        color  = StateVar<int>::Create(group, value);
-        width  = StateVar<int>::Create(group, value);
-        height = StateVar<int>::Create(group, value);
-    }
-
-    
-};
-
-TEST(StateTest, Object)
-{
-    Group g;
-
-    Widget w1( g );
-    Widget w2( g );
-
-    auto st1 = ObjectState<Widget>::Create(g, std::move(w1), w1.color, w1.width, w1.height);
-
-    auto st2 = ObjectState<Widget>::Create(in_place, g, 1337);
-
-    auto st3 = ObjectState<Widget>::Create(g, std::move(w2));
-
-    auto obs = Observer::Create([&] (const auto& ctx)
-        {
-            const Widget& widget = ctx.GetObject();
-
-            int color = ctx.Get(widget.color);
-            int width = ctx.Get(widget.width);
-            int height = ctx.Get(widget.height);
-        }, st1);
-
-    st1->color.Set(10);
-    st2->color.Set(20);
-}
\ No newline at end of file

From b45331837acfea2c3bac960abede2ee0abc593f4 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 2 Nov 2017 00:30:37 +0100
Subject: [PATCH 71/75] Test for FlattenObject. WIP algorithms examples.

---
 examples/src/BasicAlgorithms.cpp | 205 +++++++++++++++++++++----------
 tests/src/algorithm_tests.cpp    |  71 +++++++++++
 2 files changed, 210 insertions(+), 66 deletions(-)

diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index b2fa8b96..c867003f 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -37,19 +37,18 @@ namespace example1
     {
         cout << "Example 1 - Converting events to signals" << endl;
 
-        auto sensor = ObjectState<Sensor>::Create(g, Sensor{ });
+        Sensor sensor;
 
-        auto obs = Observer::Create(g, [] (const auto& ctx)
+        auto obs = Observer::Create(g, [] (int v)
             {
-                const Sensor& obj = ctx.GetObject();
-                cout << ctx.Get(obj.lastSample) << endl;
-            }, sensor);
+                cout << v << endl;
+            }, sensor.lastSample);
 
-        sensor->samples << 20 << 21 << 21 << 22; // output: 20, 21, 22
+        sensor.samples << 20 << 21 << 21 << 22; // output: 20, 21, 22
 
         g.DoTransaction([&]
             {
-                sensor->samples << 30 << 31 << 31 << 32;
+                sensor.samples << 30 << 31 << 31 << 32;
             }); // output: 32
 
         cout << endl;
@@ -343,40 +342,6 @@ namespace example6
 
 using namespace react;
 
-
-template <typename T>
-class MyContainer { };
-
-template <typename C>
-struct Flattened : public C
-{
-    using C::C;
-
-    Flattened(const C& base) :
-        C( base )
-    { }
-
-    Flattened(const C& base, int m) :
-        C( base ),
-        mode( m )
-    { }
-
-    template <typename T>
-    T* Flatten(State<T>& signal)
-    {
-        if (mode == 1)
-        {
-            memberIds_.push_back(GetInternals(signal).GetNodeId());
-        }
-        
-        return &GetInternals(signal).Value();
-    }
-
-public:
-    int mode = 0;
-    std::vector<REACT_IMPL::NodeId> memberIds_;
-};
-
 Group g;
 
 struct MyClass
@@ -384,10 +349,8 @@ struct MyClass
     StateVar<int> a = StateVar<int>::Create(g, 10);
     StateVar<int> b = StateVar<int>::Create(g, 20);
 
-    int hello = 12435;
-
     bool operator==(const MyClass& other)
-        { return hello == other.hello; }
+        { return a == other.a; }
 
     struct Flat;
 };
@@ -396,14 +359,16 @@ struct MyClass::Flat : public Flattened<MyClass>
 {
     using Flattened::Flattened;
 
-    int* a = this->Flatten(MyClass::a);
-    int* b = this->Flatten(MyClass::b);
+    Ref<int> a = this->Flatten(MyClass::a);
+    Ref<int> b = this->Flatten(MyClass::b);
 };
 
+using namespace react;
+using namespace std;
 
 void test1()
 {
-    using namespace react;
+    
 
     /*StateVar<int> x;
     State<int> y;
@@ -422,38 +387,146 @@ void test1()
 
     Flatten(g, sig);*/
 
-    StateVar<MyClass> st = StateVar<MyClass>::Create(g);
+    auto w1 = StateVar<string>::Create(g, "Widget1");
+    auto w2 = StateVar<string>::Create(g, "Widget2");
+    auto w3 = StateVar<string>::Create(g, "Widget3");
 
-    State<Ref<MyClass>> ref = CreateRef(st);
+    auto allWidgets = { CreateRef(w1), CreateRef(w2), CreateRef(w3) };
 
-    auto obs2 = Observer::Create([] (const MyClass& obj)
-        {
-            printf("aa %d\n", obj.hello);
-        }, ref);
+    auto d1 = StateVar<string>::Create(g, "Data1");
+    auto d2 = StateVar<string>::Create(g, "Data2");
+    auto d3 = StateVar<string>::Create(g, "Data3");
 
-    auto flat = FlattenObject(st);
+    auto allData = { CreateRef(d1), CreateRef(d2), CreateRef(d3) };
 
-    auto flat2 = FlattenObject(ref);
+    auto objects = StateVar<vector<StateRef<string>>>::Create(g);
 
-    auto obs = Observer::Create([] (const MyClass::Flat& obj)
+    auto obs = Observer::Create([] (const auto& flatList)
+        {
+            cout << "Objects: ";
+            for (const string& s : flatList)
+                cout << s << " ";
+            cout << endl;
+        }, FlattenList(objects));
+    // Objects:
+
+    objects.Modify([&] (auto& w)
         {
-            int x = *obj.a;
-            int y = *obj.b;
-            printf("%d\n", x);
-            printf("%d\n", y);
-        }, flat2);
+            w.push_back(CreateRef(w1));
+        });
+    // Objects: Widget1
+
+    w1.Set("Widget1 (x)");
+    // Objects: Widget1 (x)
 
+    objects.Set(allWidgets);
+    // Objects: Widget1 (x) Widget2 Widget3
 
-    GetInternals(st).Value().a.Set(999);
+    objects.Set(allData);
+    // Objects: Data1 Data2 Data3
+
+    w2.Set("Widget2 (x)");
+    
+    g.DoTransaction([&]
+        {
+            w3.Set("Widget3 (x)");
 
-    MyClass a2{ };
-    a2.hello = 3333;
+            d1.Set("Data1 (x)");
+            d2.Set("Data2 (x)");
 
-    st.Set(a2);
-    st.Set(a2);
+            objects.Set(allWidgets);
+        });
+    // Objects: Widget1 (x) Widget2 (x) Widget3 (x)
 
+    objects.Modify([&] (auto& w)
+        {
+            w.clear();
+            w.insert(end(w), allWidgets);
+            w.insert(end(w), allData);
+        });
+    // Objects: Widget1 (x) Widget2 (x) Widget3 (x) Data1 (x) Data2 (x) Data3
+    
 }
 
+class Office;
+class Company;
+class Employee;
+
+//----
+class Office
+{
+public:
+    StateVar<string> location;
+
+    StateVar<vector<State<Employee>>> employees;
+
+    State<int> employeeCount = State<int>::Create(CalcEmployeeCount, FlattenList(employees));
+
+    struct Flat;
+
+private:
+    static int CalcEmployeeCount(const vector<Employee>& offices)
+        { return offices.size(); }
+};
+
+struct Office::Flat : public Flattened<Office>
+{
+    using Flattened::Flattened;
+
+    int employeeCount = this->Flatten(Office::employeeCount);
+};
+
+//----
+class Employee
+{
+public:
+    StateVar<string> name;
+
+    StateRef<Office> office;
+
+    struct Flat;
+
+private:
+};
+
+struct Employee::Flat : public Flattened<Employee>
+{
+    using Flattened::Flattened;
+
+    Ref<string> name = this->Flatten(Employee::name);
+    Ref<Office> office = this->Flatten(Employee::office);
+};
+
+//----
+class Company
+{
+public:
+    StateVar<vector<State<Office>>> offices;
+
+    State<int> employeeCount;
+
+    struct Flat;
+
+private:
+    static int CalcEmployeeCount(const vector<Office::Flat>& offices)
+    {
+        int count = 0;
+
+        for (const auto& office : offices)
+            count += office.employeeCount;
+
+        return count;
+    }
+};
+
+struct Company::Flat : public Flattened<Company>
+{
+    using Flattened::Flattened;
+
+    Ref<vector<State<Office>>> offices = this->Flatten(Company::offices);
+    int employeeCount = this->Flatten(Company::employeeCount);
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Run examples
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/tests/src/algorithm_tests.cpp b/tests/src/algorithm_tests.cpp
index 32cac388..48432ccf 100644
--- a/tests/src/algorithm_tests.cpp
+++ b/tests/src/algorithm_tests.cpp
@@ -714,3 +714,74 @@ TEST(AlgorithmTest, IterateByRefWithState)
         EXPECT_EQ(turns2, 4);
     }
 }
+
+Group flattenGroup;
+
+class FlattenDummy
+{
+public:
+    StateVar<int> value1 = StateVar<int>::Create(flattenGroup, 10);
+    StateVar<int> value2 = StateVar<int>::Create(flattenGroup, 20);
+
+    bool operator==(const FlattenDummy& other) const
+        { return value1 == other.value1 && value2 == other.value2; }
+
+    struct Flat;
+};
+
+struct FlattenDummy::Flat : public Flattened<FlattenDummy>
+{
+    using Flattened::Flattened;
+
+    Ref<int> value1 = this->Flatten(FlattenDummy::value1);
+    Ref<int> value2 = this->Flatten(FlattenDummy::value2);
+};
+
+TEST(AlgorithmTest, FlattenObject1)
+{
+    Group g;
+
+    FlattenDummy o1;
+    FlattenDummy o2;
+
+    auto outer = StateVar<FlattenDummy>::Create(flattenGroup, o1);
+    auto flat = FlattenObject(outer);
+
+    int turns = 0;
+    int output1 = 0;
+    int output2 = 0;
+
+    auto obs = Observer::Create([&] (const FlattenDummy::Flat& v)
+        {
+            ++turns;
+            output1 = v.value1;
+            output2 = v.value2;
+        }, flat);
+
+    EXPECT_EQ(turns, 1);
+    EXPECT_EQ(output1, 10);
+    EXPECT_EQ(output2, 20);
+
+    o1.value1.Set(30);
+    o1.value2.Set(40);
+
+    EXPECT_EQ(turns, 3);
+    EXPECT_EQ(output1, 30);
+    EXPECT_EQ(output2, 40);
+
+    outer.Set(o2);
+
+    EXPECT_EQ(turns, 4);
+    EXPECT_EQ(output1, 10);
+    EXPECT_EQ(output2, 20);
+
+    o1.value1.Set(300);
+    o1.value2.Set(400);
+
+    o2.value1.Set(500);
+    o2.value2.Set(600);
+
+    EXPECT_EQ(turns, 6);
+    EXPECT_EQ(output1, 500);
+    EXPECT_EQ(output2, 600);
+}
\ No newline at end of file

From b8895308988c06b250a05bf6c359e0fa188f69f7 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 2 Nov 2017 01:33:48 +0100
Subject: [PATCH 72/75] Documentation + cleanup.

---
 include/react/algorithm.h        |  4 ++--
 include/react/common/ptrcache.h  |  9 ++++++++-
 include/react/common/slotmap.h   |  3 ++-
 include/react/common/syncpoint.h | 29 ++++++++++++++++++++++++++---
 include/react/common/utility.h   |  9 +++++----
 5 files changed, 43 insertions(+), 11 deletions(-)

diff --git a/include/react/algorithm.h b/include/react/algorithm.h
index 2390487d..c4297786 100644
--- a/include/react/algorithm.h
+++ b/include/react/algorithm.h
@@ -24,7 +24,7 @@
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Hold the most recent event in a state
+/// Holds the most recent event in a state
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, typename E>
 auto Hold(const Group& group, T&& initialValue, const Event<E>& evnt) -> State<E>
@@ -60,7 +60,7 @@ auto Monitor(const State<S>& state) -> Event<S>
     { return Monitor(state.GetGroup(), state); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Iterate - Iteratively combines state value with values from event stream (aka Fold)
+/// Iteratively combines state value with values from event stream (aka Fold)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename S, typename T, typename F, typename E>
 auto Iterate(const Group& group, T&& initialValue, F&& func, const Event<E>& evnt) -> State<S>
diff --git a/include/react/common/ptrcache.h b/include/react/common/ptrcache.h
index 50d71584..5a380060 100644
--- a/include/react/common/ptrcache.h
+++ b/include/react/common/ptrcache.h
@@ -18,12 +18,16 @@
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// Stores weak pointers to V indexed by K.
+/// A cache to objects of type shared_ptr<V> that stores weak pointers.
+/// Thread-safe.
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename K, typename V>
 class WeakPtrCache
 {
 public:
+    /// Returns a shared pointer to an object that existings in the cache, indexed by key.
+    /// If no hit was found, createFunc is used to construct the object managed by shared pointer.
+    /// A weak pointer to the result is stored in the cache.
     template <typename F>
     std::shared_ptr<V> LookupOrCreate(const K& key, F&& createFunc)
     {
@@ -32,6 +36,8 @@ class WeakPtrCache
         auto it = map_.find(key);
         if (it != map_.end())
         {
+            // Lock fails, if the object was cached before, but has been released already.
+            // In that case we re-create it.
             if (auto ptr = it->second.lock())
             {
                 return ptr;
@@ -43,6 +49,7 @@ class WeakPtrCache
         return v;
     }
 
+    /// Removes an entry from the cache.
     void Erase(const K& key)
     {
         std::lock_guard<std::mutex> scopedLock(mutex_);
diff --git a/include/react/common/slotmap.h b/include/react/common/slotmap.h
index b5b51e21..bd2a3353 100644
--- a/include/react/common/slotmap.h
+++ b/include/react/common/slotmap.h
@@ -20,7 +20,8 @@
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SlotMap
+/// A simple slot map.
+/// Insert returns the slot index, which stays valid until the element is erased.
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 template <typename T>
 class SlotMap
diff --git a/include/react/common/syncpoint.h b/include/react/common/syncpoint.h
index 1d47952a..0efb88fe 100644
--- a/include/react/common/syncpoint.h
+++ b/include/react/common/syncpoint.h
@@ -22,7 +22,16 @@
 /*****************************************/ REACT_BEGIN /*****************************************/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-/// SyncPoint
+/// A synchronization primitive that is essentially a cooperative semaphore, i.e. it blocks a
+/// consumer until all producers are done.
+/// Usage:
+///     SyncPoint sp;
+///     // Add a dependency the sync point should wait for. The depenency is released on destruction.
+///     SyncPoint::Depenency dep(sp);
+///     // Pass dependency to some operation. Dependencies can be copied as well.
+///     SomeAsyncOperation(std::move(dep));
+///     // Wait until all dependencies are released.
+///     sp.Wait()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 class SyncPoint
 {
@@ -104,6 +113,7 @@ class SyncPoint
     };
 
 public:
+    /// Creates a sync point.
     SyncPoint() :
         state_( std::make_shared<SyncPointState>() )
     { }
@@ -116,36 +126,42 @@ class SyncPoint
 
     SyncPoint& operator=(SyncPoint&&) = default;
 
+    /// Blocks the calling thread until all dependencies of this sync point are released.
     void Wait()
     {
         state_->Wait();
     }
 
+    /// Like Wait, but times out after relTime. Returns false if the timeout was hit.
     template <typename TRep, typename TPeriod>
     bool WaitFor(const std::chrono::duration<TRep, TPeriod>& relTime)
     {
         return state_->WaitFor(relTime);
     }
 
+    /// Like Wait, but times out at relTime. Returns false if the timeout was hit.
     template <typename TRep, typename TPeriod>
     bool WaitUntil(const std::chrono::duration<TRep, TPeriod>& relTime)
     {
         return state_->WaitUntil(relTime);
     }
 
+    /// A RAII-style token object that represents a dependency of a SyncPoint.
     class Dependency
     {
     public:
+        /// Constructs an unbound dependency.
         Dependency() = default;
 
-        // Construct from single sync point.
+        /// Constructs a single dependency for a sync point.
         explicit Dependency(const SyncPoint& sp) :
             target_( sp.state_ )
         {
             target_->IncrementWaitCount();
         }
 
-        // Construct from vector of other dependencies.
+        /// Merges an input range of other dependencies into a single dependency.
+        /// This allows to create APIs that are agnostic of how many dependent operations they process.        
         template <typename TBegin, typename TEnd>
         Dependency(TBegin first, TEnd last)
         {
@@ -172,6 +188,8 @@ class SyncPoint
             }
         }
 
+        /// Copy constructor and assignment split a dependency.
+        /// The new dependency that has the same target(s) as other.
         Dependency(const Dependency& other) :
             target_( other.target_ )
         {
@@ -191,6 +209,8 @@ class SyncPoint
             return *this;
         }
 
+        /// Move constructor and assignment transfer a dependency.
+        /// The moved from object is left unbound.
         Dependency(Dependency&& other) :
             target_( std::move(other.target_) )
         { }
@@ -204,12 +224,14 @@ class SyncPoint
             return *this;
         }
 
+        /// The destructor releases a dependency, if it's not unbound.
         ~Dependency()
         {
             if (target_)
                 target_->DecrementWaitCount();
         }
 
+        /// Manually releases the dependency. Afterwards it is unbound.
         void Release()
         {
             if (target_)
@@ -219,6 +241,7 @@ class SyncPoint
             }
         }
 
+        /// Returns if a dependency is released, i.e. if it is unbound.
         bool IsReleased() const
             { return target_ == nullptr; }
 
diff --git a/include/react/common/utility.h b/include/react/common/utility.h
index 8152ca3f..10464c5c 100644
--- a/include/react/common/utility.h
+++ b/include/react/common/utility.h
@@ -38,6 +38,7 @@ struct Apply<0>
     }
 };
 
+/// Use until C++17 std::apply is available.
 template<typename F, typename T>
 inline auto apply(F&& f, T&& t) -> decltype(auto)
 {
@@ -61,10 +62,12 @@ bool IsBitmaskSet(T flags, T mask)
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-// Expand args by wrapping them in a dummy function
-// Use comma operator to replace potential void return value with 0
+/// Expand args by wrapping them in a dummy function
+/// Use comma operator to replace potential void return value with 0
+/// Bware that order of calls is unspecified.
 #define REACT_EXPAND_PACK(...) REACT_IMPL::pass((__VA_ARGS__ , 0) ...)
 
+/// Bitmask helpers
 #define REACT_DEFINE_BITMASK_OPERATORS(t) \
     inline t operator|(t lhs, t rhs) \
         { return static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) | static_cast<std::underlying_type<t>::type>(rhs)); } \
@@ -81,6 +84,4 @@ bool IsBitmaskSet(T flags, T mask)
     inline t& operator^=(t& lhs, t rhs) \
         { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); return lhs; }
 
-// Bitmask helper
-
 #endif // REACT_COMMON_UTIL_H_INCLUDED
\ No newline at end of file

From 7860d4c37dafec9a068d9de5ea0059e428cfae7d Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 2 Nov 2017 10:59:56 +0100
Subject: [PATCH 73/75] Cleanup.

---
 include/react/api.h                | 6 +++---
 include/react/common/ptrcache.h    | 2 +-
 include/react/common/slotmap.h     | 6 +++---
 include/react/common/utility.h     | 6 +++---
 include/react/detail/graph_impl.h  | 6 +++---
 include/react/detail/state_nodes.h | 6 +++---
 include/react/event.h              | 3 ---
 7 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/include/react/api.h b/include/react/api.h
index 1fea1251..ffc5bc86 100644
--- a/include/react/api.h
+++ b/include/react/api.h
@@ -82,13 +82,13 @@ class Event;
 template <typename E = Token>
 class EventSource;
 
-template <typename E>
+template <typename E = Token>
 class EventSlot;
 
 template <typename E = Token>
 using EventValueList = std::vector<E>;
 
-template <typename E>
+template <typename E = Token>
 using EventValueSink = std::back_insert_iterator<std::vector<E>>;
 
 // Observer
@@ -112,4 +112,4 @@ void MapInsert(T& map, V&& value)
 
 /******************************************/ REACT_END /******************************************/
 
-#endif // REACT_TYPETRAITS_H_INCLUDED
\ No newline at end of file
+#endif // REACT_API_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/ptrcache.h b/include/react/common/ptrcache.h
index 5a380060..355ae2a2 100644
--- a/include/react/common/ptrcache.h
+++ b/include/react/common/ptrcache.h
@@ -69,4 +69,4 @@ class WeakPtrCache
 
 /******************************************/ REACT_END /******************************************/
 
-#endif // REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_COMMON_PTR_CACHE_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/slotmap.h b/include/react/common/slotmap.h
index bd2a3353..19578e59 100644
--- a/include/react/common/slotmap.h
+++ b/include/react/common/slotmap.h
@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
-#define REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
+#ifndef REACT_COMMON_SLOTMAP_H_INCLUDED
+#define REACT_COMMON_SLOTMAP_H_INCLUDED
 
 #pragma once
 
@@ -189,4 +189,4 @@ class SlotMap
 
 /******************************************/ REACT_END /******************************************/
 
-#endif // REACT_COMMON_INDEXED_STORAGE_H_INCLUDED
\ No newline at end of file
+#endif // REACT_COMMON_SLOTMAP_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/common/utility.h b/include/react/common/utility.h
index 10464c5c..1f70e747 100644
--- a/include/react/common/utility.h
+++ b/include/react/common/utility.h
@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_COMMON_UTIL_H_INCLUDED
-#define REACT_COMMON_UTIL_H_INCLUDED
+#ifndef REACT_COMMON_UTILITY_H_INCLUDED
+#define REACT_COMMON_UTILITY_H_INCLUDED
 
 #pragma once
 
@@ -84,4 +84,4 @@ bool IsBitmaskSet(T flags, T mask)
     inline t& operator^=(t& lhs, t rhs) \
         { lhs = static_cast<t>(static_cast<std::underlying_type<t>::type>(lhs) ^ static_cast<std::underlying_type<t>::type>(rhs)); return lhs; }
 
-#endif // REACT_COMMON_UTIL_H_INCLUDED
\ No newline at end of file
+#endif // REACT_COMMON_UTILITY_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/graph_impl.h b/include/react/detail/graph_impl.h
index 73110aaf..2ff28fff 100644
--- a/include/react/detail/graph_impl.h
+++ b/include/react/detail/graph_impl.h
@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef REACT_DETAIL_PROPAGATION_H_INCLUDED
-#define REACT_DETAIL_PROPAGATION_H_INCLUDED
+#ifndef REACT_DETAIL_GRAPH_IMPL_H_INCLUDED
+#define REACT_DETAIL_GRAPH_IMPL_H_INCLUDED
 
 #pragma once
 
@@ -244,4 +244,4 @@ class GroupInternals
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_PROPAGATION_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_GRAPH_IMPL_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/detail/state_nodes.h b/include/react/detail/state_nodes.h
index 9c5e6132..40858232 100644
--- a/include/react/detail/state_nodes.h
+++ b/include/react/detail/state_nodes.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#ifndef REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
-#define REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
+#ifndef REACT_DETAIL_GRAPH_STATE_NODES_H_INCLUDED
+#define REACT_DETAIL_GRAPH_STATE_NODES_H_INCLUDED
 
 #include "react/detail/defs.h"
 
@@ -416,4 +416,4 @@ static State<S> SameGroupOrLink(const Group& targetGroup, const State<S>& dep)
 
 /****************************************/ REACT_IMPL_END /***************************************/
 
-#endif // REACT_DETAIL_GRAPH_STATENODES_H_INCLUDED
\ No newline at end of file
+#endif // REACT_DETAIL_GRAPH_STATE_NODES_H_INCLUDED
\ No newline at end of file
diff --git a/include/react/event.h b/include/react/event.h
index 8dd05d46..21a186c1 100644
--- a/include/react/event.h
+++ b/include/react/event.h
@@ -59,9 +59,6 @@ class Event : protected REACT_IMPL::EventInternals<E>
     Event(Event&&) = default;
     Event& operator=(Event&&) = default;
 
-    auto Tokenize() const -> decltype(auto)
-        { return REACT::Tokenize(*this); }
-
     auto GetGroup() const -> const Group&
         { return GetNodePtr()->GetGroup(); }
 

From a8be8637db642a68727dd1fb57c2fa79af3cf900 Mon Sep 17 00:00:00 2001
From: schlangster <schlangster@gmail.com>
Date: Thu, 2 Nov 2017 11:00:32 +0100
Subject: [PATCH 74/75] Covariance for Flatten/FlattenList/FlattenMap.

---
 examples/src/BasicAlgorithms.cpp       |  8 +++---
 include/react/algorithm.h              | 36 +++++++++++++++-----------
 include/react/detail/algorithm_nodes.h | 16 ++++++------
 3 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/examples/src/BasicAlgorithms.cpp b/examples/src/BasicAlgorithms.cpp
index c867003f..7829049c 100644
--- a/examples/src/BasicAlgorithms.cpp
+++ b/examples/src/BasicAlgorithms.cpp
@@ -391,15 +391,15 @@ void test1()
     auto w2 = StateVar<string>::Create(g, "Widget2");
     auto w3 = StateVar<string>::Create(g, "Widget3");
 
-    auto allWidgets = { CreateRef(w1), CreateRef(w2), CreateRef(w3) };
+    auto allWidgets = { w1, w2, w3 };
 
     auto d1 = StateVar<string>::Create(g, "Data1");
     auto d2 = StateVar<string>::Create(g, "Data2");
     auto d3 = StateVar<string>::Create(g, "Data3");
 
-    auto allData = { CreateRef(d1), CreateRef(d2), CreateRef(d3) };
+    auto allData = { d1, d2, d3 };
 
-    auto objects = StateVar<vector<StateRef<string>>>::Create(g);
+    auto objects = StateVar<vector<StateVar<string>>>::Create(g);
 
     auto obs = Observer::Create([] (const auto& flatList)
         {
@@ -412,7 +412,7 @@ void test1()
 
     objects.Modify([&] (auto& w)
         {
-            w.push_back(CreateRef(w1));
+            w.push_back(w1);
         });
     // Objects: Widget1
 
diff --git a/include/react/algorithm.h b/include/react/algorithm.h
index c4297786..e6c3a307 100644
--- a/include/react/algorithm.h
+++ b/include/react/algorithm.h
@@ -172,54 +172,60 @@ auto Pulse(const State<S>& state, const Event<E>& evnt) -> Event<S>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// Flatten
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
-auto Flatten(const Group& group, const State<State<S>>& state) -> State<S>
+template <typename S, template <typename> class TState,
+    typename = std::enable_if_t<std::is_base_of_v<State<S>, TState<S>>>>
+auto Flatten(const Group& group, const State<TState<S>>& state) -> State<S>
 {
     using REACT_IMPL::FlattenStateNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
-    return CreateWrappedNode<State<S>, FlattenStateNode<S>>(group, SameGroupOrLink(group, state));
+    return CreateWrappedNode<State<S>, FlattenStateNode<S, TState>>(group, SameGroupOrLink(group, state));
 }
 
-template <typename S>
-auto Flatten(const State<State<S>>& state) -> State<S>
+template <typename S, template <typename> class TState,
+    typename = std::enable_if_t<std::is_base_of_v<State<S>, TState<S>>>>
+auto Flatten(const State<TState<S>>& state) -> State<S>
     { return Flatten(state.GetGroup(), state); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenList
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <template <typename ...> class TList, typename V, typename ... TParams>
-auto FlattenList(const Group& group, const State<TList<State<V>, TParams ...>>& list) -> State<TList<V>>
+template <template <typename ...> class TList, template <typename> class TState, typename V, typename ... TParams,
+    typename = std::enable_if_t<std::is_base_of_v<State<V>, TState<V>>>>
+auto FlattenList(const Group& group, const State<TList<TState<V>, TParams ...>>& list) -> State<TList<V>>
 {
     using REACT_IMPL::FlattenStateListNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
-    return CreateWrappedNode<State<TList<V>>, FlattenStateListNode<TList, V, TParams ...>>(
+    return CreateWrappedNode<State<TList<V>>, FlattenStateListNode<TList, TState, V, TParams ...>>(
         group, SameGroupOrLink(group, list));
 }
 
-template <template <typename ...> class TList, typename V, typename ... TParams>
-auto FlattenList(const State<TList<State<V>, TParams ...>>& list) -> State<TList<V>>
+template <template <typename ...> class TList, template <typename> class TState, typename V, typename ... TParams,
+    typename = std::enable_if_t<std::is_base_of_v<State<V>, TState<V>>>>
+auto FlattenList(const State<TList<TState<V>, TParams ...>>& list) -> State<TList<V>>
     { return FlattenList(list.GetGroup(), list); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenMap
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <template <typename ...> class TMap, typename K, typename V, typename ... TParams>
-auto FlattenMap(const Group& group, const State<TMap<K, State<V>, TParams ...>>& map) -> State<TMap<K, V>>
+template <template <typename ...> class TMap, template <typename> class TState, typename K, typename V, typename ... TParams,
+    typename = std::enable_if_t<std::is_base_of_v<State<V>, TState<V>>>>
+auto FlattenMap(const Group& group, const State<TMap<K, TState<V>, TParams ...>>& map) -> State<TMap<K, V>>
 {
     using REACT_IMPL::FlattenStateMapNode;
     using REACT_IMPL::SameGroupOrLink;
     using REACT_IMPL::CreateWrappedNode;
 
-    return CreateWrappedNode<State<TMap<K, V>>, FlattenStateMapNode<TMap, K, V, TParams ...>>(
+    return CreateWrappedNode<State<TMap<K, V>>, FlattenStateMapNode<TMap, TState, K, V, TParams ...>>(
         group, SameGroupOrLink(group, map));
 }
 
-template <template <typename ...> class TMap, typename K, typename V, typename ... TParams>
-auto FlattenMap(const State<TMap<K, State<V>, TParams ...>>& map) -> State<TMap<K, V>>
+template <template <typename ...> class TMap, template <typename> class TState, typename K, typename V, typename ... TParams,
+    typename = std::enable_if_t<std::is_base_of_v<State<V>, TState<V>>>>
+auto FlattenMap(const State<TMap<K, TState<V>, TParams ...>>& map) -> State<TMap<K, V>>
     { return FlattenMap(map.GetGroup(), map); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/react/detail/algorithm_nodes.h b/include/react/detail/algorithm_nodes.h
index ec091f0c..d730f51c 100644
--- a/include/react/detail/algorithm_nodes.h
+++ b/include/react/detail/algorithm_nodes.h
@@ -375,11 +375,11 @@ class PulseNode : public EventNode<S>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenStateNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <typename S>
+template <typename S, template <typename> class TState>
 class FlattenStateNode : public StateNode<S>
 {
 public:
-    FlattenStateNode(const Group& group, const State<State<S>>& outer) :
+    FlattenStateNode(const Group& group, const State<TState<S>>& outer) :
         FlattenStateNode::StateNode( group, GetInternals(GetInternals(outer).Value()).Value() ),
         outer_( outer ),
         inner_( GetInternals(outer).Value() )
@@ -421,18 +421,18 @@ class FlattenStateNode : public StateNode<S>
     }
 
 private:
-    State<State<S>> outer_;
-    State<S>        inner_;
+    State<TState<S>>    outer_;
+    State<S>            inner_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenStateListNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <template <typename ...> class TList, typename V, typename ... TParams>
+template <template <typename ...> class TList, template <typename> class TState, typename V, typename ... TParams>
 class FlattenStateListNode : public StateNode<TList<V>>
 {
 public:
-    using InputListType = TList<State<V>, TParams ...>;
+    using InputListType = TList<TState<V>, TParams ...>;
     using FlatListType = TList<V>;
 
     FlattenStateListNode(const Group& group, const State<InputListType>& outer) :
@@ -501,11 +501,11 @@ class FlattenStateListNode : public StateNode<TList<V>>
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 /// FlattenStateListNode
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-template <template <typename ...> class TMap, typename K, typename V, typename ... TParams>
+template <template <typename ...> class TMap, template <typename> class TState, typename K, typename V, typename ... TParams>
 class FlattenStateMapNode : public StateNode<TMap<K, V>>
 {
 public:
-    using InputMapType = TMap<K, State<V>, TParams ...>;
+    using InputMapType = TMap<K, TState<V>, TParams ...>;
     using FlatMapType = TMap<K, V>;
 
     FlattenStateMapNode(const Group& group, const State<InputMapType>& outer) :

From 5e9a2a017d5a0f3439b0288977feec6a22d6b850 Mon Sep 17 00:00:00 2001
From: Sebastian <84207751+snakster@users.noreply.github.com>
Date: Tue, 18 May 2021 01:13:04 +0200
Subject: [PATCH 75/75] Fix URLs after move.

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index f38e6486..39bf846c 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ![C++React](http://schlangster.github.io/cpp.react//media/logo_banner3.png)
+# ![C++React](http://snakster.github.io/cpp.react//media/logo_banner3.png)
 
 C++React is reactive programming library for C++14. It enables the declarative definition of data dependencies between state and event flows.
 Based on these definitions, propagation of changes is handled automatically.
@@ -37,4 +37,4 @@ The system also knows when it's safe to update values in parallel from multiple
 
 I'm currently in the process of rewriting the library more or less from scratch and many things are still broken or outdated.
 
-[The old, but stable and documented version is still available in this branch.](https://github.com/schlangster/cpp.react/tree/legacy1)
\ No newline at end of file
+[The old, but stable and documented version is still available in this branch.](https://github.com/snakster/cpp.react/tree/legacy1)