wait | k8s wait and backoff utilities , extracted for general use | Reactive Programming library

When you're using cmake, you're not expected to modify the compiler options by changing the invocation of make. Instead, you're expected to modify the compiler options by either editing the CMakeLists.txt file, or else by providing an overridden value to the cmake command line that is used to generate your makefiles.

Ok, but yours is an unnecessarily difficult approach. At each step of the merge process, you want half of your threads to wait for the other half to finish, and the most natural way for one thread to wait for another to finish is to use pthread_join(). If you wanted all of your threads to continue with more work after synchronizing then that would be different, but in this case, those that are not responsible for any more merges have nothing at all left to do.

This is what I've tried:

It seems that an async method will break a method chain, there's no way around that. And since fetch is asynchronous, await must be used, and in order for await to be used, the calling method must be declared async. Thus the method chain will be broken.

The way the method chain is called must be changed.

In my OP, I linked https://jsfiddle.net/47sfj3Lv/3/ as a much simpler version of the same problem. StackOverflow's 'fiddle' effectively blocks 'fetch' for security reasons, so I need to use JSFiddle for demonstration.

Here's a working version of the same code using then and how/why it works, and a slightly shorter version, because await can be specified with the the fetch, obviously.

That is not quite correct. Tail recursion mostly enables the compiler to apply tail call optimization (if supported), i.e. to rewrite the recursion to a regular loop instead. This has the advantage not reduced memory usage in the stack. It has nothing to do with 'not waiting'.

In the first example it has to keep one stack frame for each item in the list, and if you have a long list there is a chance you will run out of stack memory and get a stackoverflow.

In the tail recursive case the current stack frame is no longer needed when it reaches the tail-call, so the same stack frame can be re-used for each call, and that should result in code sort of equivalent to a regular loop.

Is this implementation the right way to achieve that?

It looks fine to me. But that does not necessarily mean that the optimization will be applied, it seem to depend on the compiler version, and may have other requirements. See Why doesn't .NET/C# optimize for tail-call recursion? In general I would recommend relying on the language specification and not compiler optimization for correct function of your program.

Note that recursion is often not the ideal approach in c#. For something simple as a sum it is easier, faster, and more readable to use a regular loop. For more complicated cases, like iterating over trees, recursion can be appropriate, but then tail-call optimization will not help very much in that case.

https://developer.apple.com/news/?id=c88acm2b

pushsharp has it on the roadmap to support the new interface but not completed yet.

Found this library which seems easy enough to use as a solution. hope this helps.

https://github.com/alexalok/dotAPNS

try this :