Impove lambda handling

Author: endurodave

01_fetch_repos.py

@@ -87,18 +87,27 @@ def run():
     workspace_dir = os.path.abspath(os.path.join(script_dir, ".."))
     print(f"Target Workspace: {workspace_dir}\n")
 
+    # Suppress 'detached HEAD' advice to keep output clean
+    subprocess.run(["git", "config", "advice.detachedHead", "false"], check=False)
+
     # 1. Clone Repos
     for folder, (url, tag, use_submodules) in repos.items():
         target_path = os.path.join(workspace_dir, folder)
         if not os.path.exists(target_path):
             print(f"[CLONING] {folder} (Tag: {tag if tag else 'HEAD'})...")
-            cmd = ["git", "clone"]
+            # Use -c advice.detachedHead=false to silence the warning during clone
+            cmd = ["git", "-c", "advice.detachedHead=false", "clone", "--quiet"]
             if use_submodules: cmd.append("--recurse-submodules")
             if tag: cmd.extend(["--branch", tag])
             else: cmd.extend(["--depth", "1"])
             cmd.extend([url, target_path])
-            try: subprocess.run(cmd, check=True)
-            except: print(f"   [ERROR] Failed to clone {folder}")
+            try:
+                # Capture stderr to suppress normal output; printed only on failure
+                subprocess.run(cmd, check=True, stderr=subprocess.PIPE)
+            except subprocess.CalledProcessError as e:
+                print(f"   [ERROR] Failed to clone {folder}")
+                if e.stderr:
+                    print(e.stderr.decode(errors="replace"))
         else:
             print(f"[SKIP] {folder} exists.")
 

README.md

@@ -239,7 +239,8 @@ public:
     MsgSender(ITransport& transport, ISerializer<void(std::string)>& ser)
         : m_channel(transport, ser)
     {
-        m_channel.Bind(std::function<void(std::string)>([](std::string){}), MSG_ID);
+        // Bind to a raw lambda (no std::function wrapper needed)
+        m_channel.Bind([](std::string msg) { MsgOut(msg); }, MSG_ID);
     }
 
     void Send(const std::string& msg) { m_channel(msg); }  // fire-and-forget

docs/DETAILS.md

@@ -379,19 +379,19 @@ if (result.has_value())
 
 ### Lambdas
 
-Lambdas work the same way. Use `+` to convert a stateless lambda to a function pointer, or wrap capturing lambdas in `std::function`.
+Lambdas work the same way. Pass any lambda directly to `MakeDelegate()` — no `std::function` wrapper or `+` conversion needed.
 
 ```cpp
 // Stateless lambda — synchronous
-auto echo = MakeDelegate(+[](const std::string& s) { std::cout << s; });
+auto echo = MakeDelegate([](const std::string& s) { std::cout << s; });
 echo("hello");
 
 // Capturing lambda — asynchronous, fire-and-forget
 int threshold = 10;
 auto check = MakeDelegate(
-    std::function<void(int)>([threshold](int v) {
+    [threshold](int v) {
         if (v > threshold) std::cout << "Over threshold\n";
-    }),
+    },
     workerThread
 );
 check(15);
@@ -458,12 +458,12 @@ Button btn;
 
 // Subscriber A: synchronous (called on the emitting thread)
 dmq::ScopedConnection connA = btn.OnPressed.Connect(
-    MakeDelegate(+[](int id) { std::cout << "Sync: " << id; })
+    MakeDelegate([](int id) { std::cout << "Sync: " << id; })
 );
 
 // Subscriber B: asynchronous (called on workerThread)
 dmq::ScopedConnection connB = btn.OnPressed.Connect(
-    MakeDelegate(+[](int id) { std::cout << "Async: " << id; }, workerThread)
+    MakeDelegate([](int id) { std::cout << "Async: " << id; }, workerThread)
 );
 
 btn.Press(1);  // connA called synchronously, connB queued on workerThread
@@ -475,14 +475,14 @@ btn.Press(1);  // connA called synchronously, connB queued on workerThread
 dmq::Signal<void(int)> OnData;
 
 // Stateless lambda
-dmq::ScopedConnection c1 = OnData.Connect(MakeDelegate(+[](int v) {
+dmq::ScopedConnection c1 = OnData.Connect(MakeDelegate([](int v) {
     std::cout << "Got: " << v << "\n";
 }));
 
-// Capturing lambda
+// Capturing lambda — no std::function wrapper needed
 int factor = 3;
 dmq::ScopedConnection c2 = OnData.Connect(MakeDelegate(
-    std::function<void(int)>([factor](int v) { std::cout << v * factor; })
+    [factor](int v) { std::cout << v * factor; }
 ));
 
 OnData(10);  // both slots called
@@ -867,12 +867,10 @@ auto delegateMember = MakeDelegate(&testClass, &TestClass::MemberFunc);
 delegateMember(&testStruct);
 ```
 
-Bind a lambda function is easy using `std::function`.
+Bind a lambda directly — no `std::function` wrapper needed.
 
 ```cpp
-std::function<bool(int)> rangeLambda = MakeDelegate(
-    +[](int v) { return v > 2 && v <= 6; }
-);
+auto rangeLambda = MakeDelegate([](int v) { return v > 2 && v <= 6; });
 bool inRange = rangeLambda(6);
 ```
 
@@ -988,14 +986,14 @@ Stack arguments passed by pointer/reference do not be thread-safe. The reason is
 A blocking delegate must specify a timeout in milliseconds or `WAIT_INFINITE`. Unlike a non-blocking asynchronous delegate, which is guaranteed to be invoked, if the timeout expires on a blocking delegate, the function is not invoked. Use `IsSuccess()` to determine if the delegate succeeded or not.
 
 ```cpp
-std::function LambdaFunc1 = [](int i) -> int
-{
-    cout << "Called LambdaFunc1 " << i << std::endl;
-    return ++i;
-};
-
 // Asynchronously invoke lambda on workerThread1 and wait for the return value
-auto lambdaDelegate1 = MakeDelegate(LambdaFunc1, workerThread1, WAIT_INFINITE);
+auto lambdaDelegate1 = MakeDelegate(
+    [](int i) -> int {
+        cout << "Called LambdaFunc1 " << i << std::endl;
+        return ++i;
+    },
+    workerThread1, WAIT_INFINITE
+);
 int lambdaRetVal2 = lambdaDelegate1(123);
 ```
 
@@ -1004,7 +1002,7 @@ Delegates are callable and therefore may be passed to the standard library. The
 ```cpp
 std::vector<int> v{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 
-auto CountLambda = +[](int v) -> int
+auto CountLambda = [](int v) -> int
 {
     return v > 2 && v <= 6;
 };
@@ -1549,12 +1547,11 @@ void TestFunc(TestStruct* data);
 Occasionally, you may not want the delegate library to copy your arguments. Instead, you just want the destination thread to have a pointer to the original copy. A `std::shared_ptr` function argument does not copy the object pointed to when using an asynchronous delegate target function. 
 
 ```cpp
-std::function lambFunc = [](std::shared_ptr<TestStruct> s) {};
-auto del = MakeDelegate(lambFunc, workerThread1);
+auto del = MakeDelegate([](std::shared_ptr<TestStruct> s) {}, workerThread1);
 std::shared_ptr<TestStruct> sp = std::make_shared<TestStruct>();
 
-// Invoke lambFunc and TestStruct instance is not copied
-del(sp);   
+// Invoke lambda and TestStruct instance is not copied
+del(sp);
 ```
 
 ### Array Argument Heap Copy

example/sample-code/AllTargets.cpp

@@ -43,15 +43,15 @@ namespace Example
         };
 
         int stackVal = 100;
-        std::function<void(int)> LambdaCapture = [stackVal](int i) {
+        auto LambdaCapture = [stackVal](int i) {
             std::cout << "LambdaCapture " << i + stackVal << " " << ++callCnt << endl;
         };
 
-        std::function<void(int)> LambdaNoCapture = [](int i) {
+        auto LambdaNoCapture = [](int i) {
             std::cout << "LambdaNoCapture " << i << " " << ++callCnt << endl;
         };
 
-        std::function<void(int)> LambdaForcedCapture = +[](int i) {
+        auto LambdaForcedCapture = +[](int i) {
             std::cout << "LambdaForcedCapture " << i << " " << ++callCnt << endl;
         };
 

example/sample-code/AsyncCallback.cpp

@@ -164,11 +164,9 @@ namespace Example
         monitor->Init(sensor, callback_thread);
 
         // 4. Setup Lambda (ScopedConnection)
-        std::function<void(int, const std::string&)> lambdaFunc =
-            [](int val, const std::string& src) {
+        auto lambdaConnection = sensor.OnData.Connect(MakeDelegate([](int val, const std::string& src) {
             cout << "[Lambda] Got " << val << " on thread " << Thread::GetCurrentThreadId() << endl;
-            };
-        auto lambdaConnection = sensor.OnData.Connect(MakeDelegate(lambdaFunc, callback_thread));
+        }, callback_thread));
 
         // 5. Produce Data
         cout << "\n--- Producing Batch 1 ---" << endl;

example/sample-code/BindingProperty.cpp

@@ -59,15 +59,15 @@ namespace Example
         PropertyBinding() : workerThread("Example"), property1(0), property2(0), property3(0) {
             workerThread.CreateThread();
 
-            std::function<void(int)> lambda2 = [this](int new_value) {
+            auto lambda2 = [this](int new_value) {
                 // Whenever property1 changes, set property2 to double the value
                 property2.set(new_value * 2);
             };
 
             // Bind property2 to property1's changes (synchonous binding)
             property1.bind(MakeDelegate(lambda2));  
 
-            std::function<void(int)> lambda3 = [this](int new_value) {
+            auto lambda3 = [this](int new_value) {
                 const std::lock_guard<std::mutex> lk(lock);
                 // Whenever property1 changes, set property3 to triple the value
                 property3.set(new_value * 3);

example/sample-code/Observer.cpp

@@ -105,7 +105,7 @@ namespace Example
         subject.attach(MakeDelegate(observerB, &ConcreteObserverB::update));
         subject.attach(MakeDelegate(SubjectFree));
         subject.attach(MakeDelegate(SubjectLambda));
-        subject.attach(MakeDelegate(std::function(SubjectLambda2)));
+        subject.attach(MakeDelegate(SubjectLambda2));
 
         // Change the subject's state and notify observers
         std::cout << "Setting state to 20:" << std::endl;

example/sample-code/RemoteCommunication.cpp

@@ -91,7 +91,8 @@ namespace Example
             , m_channel(transport, m_serializer)
         {
             // Sender-side bind: no-op target (only the signature matters for dispatch)
-            m_channel.Bind(std::function<void(Data)>([](Data) {}), id);
+            // Bind a raw lambda (no std::function wrapper needed)
+            m_channel.Bind([](Data msg) { std::cout << "Remote lambda data: " << msg.x << std::endl; }, id);
 
             m_thread.CreateThread();
 

example/sample-projects/databus-shapes/client/main.cpp

@@ -55,7 +55,6 @@ int main() {
     static Serializer<void(ShapeMsg)> serializer;
 
     auto shapeHandler = [](const std::string& topic, ShapeMsg msg) {
-        // std::cout << "DEBUG: Received " << topic << " x=" << msg.x << " y=" << msg.y << std::endl;
         {
             std::lock_guard<std::mutex> lock(g_state.mutex);
             g_state.shapes[topic] = msg;
@@ -65,11 +64,9 @@ int main() {
         }
     };
 
-    // Use explicit std::function to match RegisterHandler signature
-    using HandlerFunc = std::function<void(ShapeMsg)>;
-    group->RegisterHandler<ShapeMsg>(SystemTopic::SquareId, serializer, HandlerFunc([&](ShapeMsg m) { shapeHandler(SystemTopic::Square, m); }));
-    group->RegisterHandler<ShapeMsg>(SystemTopic::CircleId, serializer, HandlerFunc([&](ShapeMsg m) { shapeHandler(SystemTopic::Circle, m); }));
-    group->RegisterHandler<ShapeMsg>(SystemTopic::TriangleId, serializer, HandlerFunc([&](ShapeMsg m) { shapeHandler(SystemTopic::Triangle, m); }));
+    group->RegisterHandler<ShapeMsg>(SystemTopic::SquareId, serializer, [&](ShapeMsg m) { shapeHandler(SystemTopic::Square, m); });
+    group->RegisterHandler<ShapeMsg>(SystemTopic::CircleId, serializer, [&](ShapeMsg m) { shapeHandler(SystemTopic::Circle, m); });
+    group->RegisterHandler<ShapeMsg>(SystemTopic::TriangleId, serializer, [&](ShapeMsg m) { shapeHandler(SystemTopic::Triangle, m); });
 
     // 3. Network processing thread
     std::atomic<bool> running{true};

example/sample-projects/databus/client/main.cpp

@@ -90,14 +90,13 @@ int main() {
     dmq::DataBus::RegisterSerializer<CommandMsg>(SystemTopic::CommandMsg, commandSerializer);
 
     // 7. Monitor reliability signal to detect server response status
-    using StatusSignal = std::function<void(dmq::DelegateRemoteId, uint16_t, TransportMonitor::Status)>;
-    auto statusConn = monitor.OnSendStatus.Connect(dmq::MakeDelegate(StatusSignal([](dmq::DelegateRemoteId id, uint16_t seq, TransportMonitor::Status status) {
+    auto statusConn = monitor.OnSendStatus.Connect(dmq::MakeDelegate([](dmq::DelegateRemoteId id, uint16_t seq, TransportMonitor::Status status) {
         if (status == TransportMonitor::Status::TIMEOUT) {
             std::cerr << "!!! ALERT: Server not responding to command (RemoteID: " << id << " Seq: " << seq << ")" << std::endl;
         } else {
             std::cout << "Command ACK received (Seq: " << seq << ")" << std::endl;
         }
-    })));
+    }));
 
     // 8. Local Subscription to DataBus
     auto conn = dmq::DataBus::Subscribe<DataMsg>(SystemTopic::DataMsg, [](DataMsg msg) {