I've thought of a really good use for this.

I have a program running a superloop on an Arduino microcontroller. In order to keep the iteration time of the superloop below 100 milliseconds, I only allow it to send one message per iteration of the superloop.

To send a message, I call:

    gSimGsm.send("whatever");

which will return true if it sent a message, or return false if it failed because there had already been one message sent in that iteration of the superloop.

And so I wrote a class called SuperloopManager, which you can use as follows:

    gSuperloopManager.DeferUntilTrue([]{ send("whatever"); });

The above line of code will immediately try to send a message, but if it cannot because there has already been a message sent in the current iteration of the superloop, then it will defer it until the next iteration. It will keep invoking that lambda upon each iteration of the superloop until the lambda returns true.

But the problem is that if the message keeps getting deferred again and again and again, then the program might reach a point where it enqueues the same message a second time. Then we'll have two of the same message waiting in the queue, and if it happens a third time and a fourth time then the queue will become full and my microcontroller will reset.

To remedy this, I was considering putting a unique ID at every callsite, something like:

    enum { msg_monkey, msg_donkey, msg_goat };

    gSuperloopManager.DeferUntilTrue(msg_monkey, []{ send("whatever"); });

And then I would check the ID to ensure that the message in question isn't already in the queue.

But it would be more convenient to do:

    class SuperloopManager {

        template<typename = decltype([]{})>

        void DeferUntilTrue(std::function<void(void)> &&arg)

        {

            static char dummy;

            // code here

        }

    };

And then I could use the address of 'dummy' as a compile-time constant to identify the message and to disallow a double-queuing.