I'd like to include this library in the vcpkg package catalog (https://github.com/microsoft/vcpkg/pull/20340) but ran into an issue that would be nice to get addressed here in the library instead of having to be patched on the vcpkg side.

Currently, the library puts all its header files directly under include. This could be problematic because there may be clashes with other libraries that use the same names for their include files, especially since some of the headers use generic names like add_ons.hpp.

I suggest to put all headers into a subfolder promise-cpp or similar, and refer to them via #include "promise-cpp/...hpp" in all files.

First of all, thank you for the perfect lib! Promise implementation is good and clean. Looking into the lib deeply.

After running this simple line code using Catch framework with valgrind --leak-check=full --show-leak-kinds=all :

TEST_CASE("Test") {
    promise::Defer promise = promise::newPromise();
}

two "still reachable" warnings was thrown:

=3030== 24 bytes in 1 blocks are still reachable in loss record 1 of 2
==3030==    at 0x4C2F1CA: operator new(unsigned long) (vg_replace_malloc.c:334)
==3030==    by 0x7A3C56: promise::pm_memory_pool* promise::pm_stack_new<promise::pm_memory_pool, unsigned long>(unsigned long&&) (stack.hpp:122)
==3030==    by 0x7A390A: promise::pm_size_allocator<56ul>::get_memory_pool() (allocator.hpp:94)
==3030==    by 0x7A347A: void* promise::pm_allocator::obtain<promise::Promise>() (allocator.hpp:195)
==3030==    by 0x7A2DBD: promise::Promise* promise::pm_new<promise::Promise>() (allocator.hpp:216)
==3030==    by 0x7A2913: promise::newPromise() (promise.hpp:1221)
==3030==    by 0x933DA9: ____C_A_T_C_H____T_E_S_T____8() (promise_test.cpp:126)
==3030==    by 0x8E0089: Catch::FreeFunctionTestCase::invoke() const (catch_test_case_registry_impl.hpp:150)
==3030==    by 0x8BAF1C: Catch::TestCase::invoke() const (catch_test_case_info.hpp:176)
==3030==    by 0x8DEE48: Catch::RunContext::invokeActiveTestCase() (catch_run_context.hpp:367)
==3030==    by 0x8DEBEB: Catch::RunContext::runCurrentTest(std::string&, std::string&) (catch_run_context.hpp:340)
==3030==    by 0x8DD934: Catch::RunContext::runTest(Catch::TestCase const&) (catch_run_context.hpp:131)
==3030==
==3030== 88 bytes in 1 blocks are still reachable in loss record 2 of 2
==3030==    at 0x4C2F8B7: operator new[](unsigned long) (vg_replace_malloc.c:423)
==3030==    by 0x7A1A48: promise::pm_allocator::obtain_impl(promise::pm_memory_pool*, unsigned long) (allocator.hpp:118)
==3030==    by 0x7A348F: void* promise::pm_allocator::obtain<promise::Promise>() (allocator.hpp:196)
==3030==    by 0x7A2DBD: promise::Promise* promise::pm_new<promise::Promise>() (allocator.hpp:216)
==3030==    by 0x7A2913: promise::newPromise() (promise.hpp:1221)
==3030==    by 0x933DA9: ____C_A_T_C_H____T_E_S_T____8() (promise_test.cpp:126)
==3030==    by 0x8E0089: Catch::FreeFunctionTestCase::invoke() const (catch_test_case_registry_impl.hpp:150)
==3030==    by 0x8BAF1C: Catch::TestCase::invoke() const (catch_test_case_info.hpp:176)
==3030==    by 0x8DEE48: Catch::RunContext::invokeActiveTestCase() (catch_run_context.hpp:367)
==3030==    by 0x8DEBEB: Catch::RunContext::runCurrentTest(std::string&, std::string&) (catch_run_context.hpp:340)
==3030==    by 0x8DD934: Catch::RunContext::runTest(Catch::TestCase const&) (catch_run_context.hpp:131)
==3030==    by 0x8B8321: Catch::runTests(Catch::Ptr<Catch::Config> const&) (catch_session.hpp:82)

I guess both point to custom memory allocator:

The first one:

promise::pm_memory_pool* promise::pm_stack_new<promise::pm_memory_pool, unsigned long>(unsigned long&&) (stack.hpp:122)

The second:

promise::pm_allocator::obtain_impl(promise::pm_memory_pool*, unsigned long) (allocator.hpp:118)

In both cases I see memory allocation which are once allocated (fix me if I'm wrong) will never be freed.

I'm not sure this is 100% memory leak, but in more complex production examples instead of "still reachable" I see "possibly lost" or even "definitely lost" warnings pointing to the same lines of code.

Could you please clarify this issue, I saw static thread_local memory pooling logic inside, so maybe we could implement some function whose responsibility would be to clear all the pools manually to make valgrind happy? Like this:

TEST_CASE("Test") {
    promise::Defer promise = promise::newPromise();
    promise::pm_allocator::free_pools();
}

Thank you.

Hello, thank you for sharing your code.

I'd like to call then(f()) with a function that returns a promise. My suggestion is to add an overload for Defer&&, but anything that makes the included test pass is fine with me.

I'd also suggest to provide an "install" target.

Happy new year, Paul

Sorry, I think I took out too much last PR with the PROMISE_BUILD_EXAMPLES option. I did go a bit further and rearranged the structure slightly. Now I can do the following

include(FetchContent)
FetchContent_Declare(
    promise
    GIT_REPOSITORY https://github.com/xhawk18/promise-cpp.git
    GIT_TAG        e41e25c9b078141ff2e499cd6a2678386b67311e
)
FetchContent_MakeAvailable(promise)

add_executable(myProgram ...)
target_link_library(myProgram PRIVATE promise)

#include <promise-cpp/promise.hpp>
// Notice that these are now directly available, and can be used when boost is found:
#include <promise-cpp/add_ons/asio/timer.hpp>

int main()
{
  setTimeout(...)
}

target_link_library(mything PRIVATE promise)

is not sufficient, because promise does not provide its include directory to the using target. I changed that.

I also made the example builds optional via an option, so I can omit them in my project. Please crosscheck that I didnt opt-out too much!

I swore I submitted this as a PR, but for the life of me I cannot find it. This removes a warning for a lock that is shadowed. In theory I shouldn't be an issue, but I noticed a few errors in helgrind warning about mutex locks forming out of order. 99.9% sure its boost asio, but this caught my eye.

Greetings, I have the following code:

std::vector<Promise> promise_list = { 
  promise::resolve<float>(10),
  promise::resolve<float>(11),
};

all(promise_list).then([](const std::vector<float> &vals){
    /* code here for all promise objects are resolved */
}).fail([](){
    /* code here for one of the promise objects is rejected */
});

This compiles but bails with a bad any_cast execption. The following though works:

std::vector<Promise> promise_list = { 
promise::resolve<float>(10),
promise::resolve<float>(11),
};

all(promise_list).then([](const std::vector<any> &vals){
   std::vector<float> res{};
   std::transform(vals.begin(), vals.end(), std::back_inserter(res),
                           [](const promise::any &r) { return r.cast<float>(); });
  return res;
}).then([](const std::vector<float> &vals){
    /* code here for all promise objects are resolved as floats */
}).fail([](){
    /* code here for one of the promise objects is rejected */
});

I am wondering if you can use the container std::vector<T>::value_type for the cast from the promise into the function. I am not sure if this would break other stuff though since it would need to happen after resolution. This would also break instances where you have multiple types returned by the promises. Thoughts?

The following does not work using clang 14

auto promise = newPromise([](Defer d){ /*...*/ });
promise.then([bla]() mutable {
});

with "call_traits.hpp:135:20: error: call to pointer to member function of type 'void ()' drops 'const' qualifier"

Hi, I'm trying to use promise-cpp in multi-threaded programs, but sometimes the following assertion error occurs in promise-cpp.

promise_inl.hpp(161)

            std::list<std::shared_ptr<Task>> &pendingTasks = promiseHolder->pendingTasks_;
            //promiseHolder->dump();
            assert(pendingTasks.front() == task); // Assertion failed: (pendingTasks.front() == task), function call, file promise_inl.hpp, line 161.
            pendingTasks.pop_front();
            //promiseHolder->dump();

The README document says promise-cpp is thread safe but It seems not thread safe in some situation.

Is this a bug? Or should I fix how I use promise-cpp? Thanks.

Step to reproduce:

Build and run this code snippet.

#include <iostream>
#include <memory>
#include <vector>
#include <thread>
#include <functional>
#include <mutex>
#include <atomic>
#include <deque>
#include <stdexcept>

#define PROMISE_HEADONLY
#include <promise-cpp/promise.hpp>

struct ThreadPool
{
    ThreadPool() {}
    ~ThreadPool() {}

    void startThreads(int num) {
        stopThreads();
        _shouldStop = false;
        for(int i = 0; i < num; ++i) {
            auto th = std::thread([this] { threadProcess(); });
            _threads.push_back(std::move(th));
        }
    }

    void stopThreads() {
        _shouldStop = true;
        std::for_each(_threads.begin(), _threads.end(),
                      [](auto &th) { th.join(); });
    }

    void addTask(std::function<void()> f) {
        auto lock = std::unique_lock<std::mutex>(_mtx);
        _tasks.push_back(f);
        _cvEmpty.notify_all();
    }

    void threadProcess()
    {
        for( ; ; ) {
            if(_shouldStop) { break; }

            std::function<void()> f;
            {
                auto lock = std::unique_lock<std::mutex>(_mtx);

                auto result = _cvEmpty.wait_for(lock, std::chrono::milliseconds(100), [&] {
                    return _tasks.size() > 0;
                });

                if(result == false) { continue; }

                f = _tasks.front();
                _tasks.pop_front();
            }

            f();
        }
    }

private:
    std::mutex _mtx;
    std::deque<std::function<void()>> _tasks;
    std::vector<std::thread> _threads;
    std::atomic<bool> _shouldStop = { false };
    std::condition_variable _cvEmpty;

public:
    static ThreadPool * getInstance() { return _instance.load(); }
    static ThreadPool * setInstance(ThreadPool *inst) { return _instance.exchange(inst); }

private:
    static inline std::atomic<ThreadPool *> _instance;
};

promise::Promise yield_async()
{
    return promise::newPromise([](promise::Defer defer) {
        ThreadPool::getInstance()->addTask([defer] {
            defer.resolve();
        });
    });
}

int main()
{
    std::cout << "Start." << std::endl;
    ThreadPool pool;
    ThreadPool::setInstance(&pool);

    pool.startThreads(10);

    auto finished = std::make_shared<bool>(false);

    static auto func = [=] {
        return yield_async().then([] {
            return true;
        });
    };

    {
        auto count = std::make_shared<std::atomic<int>>(0);

        promise::doWhile([=](promise::DeferLoop loop) {
            if(*count >= 300) {
                loop.doBreak(count->load());
                return;
            }

            promise::newPromise([=](promise::Defer defer) {
                func().then([=](bool b) {
                    bool x = b;
                }).then([=] {
                    return yield_async();
                }).then([=] {
                    defer.resolve();
                });

            }).then([=] {
                *count += 1;
                std::cout << "count: " << *count << std::endl;
                yield_async().then([=] {
                    loop.doContinue();
                });
            });
        }).then([=](int n) {
            std::cout << "hello : " << n << std::endl;
            *finished = true;
        });
    };

    pool.stopThreads();
    ThreadPool::setInstance(nullptr);

    std::cout << "Finished." << std::endl;
    return 0;
}

struct Test {
    Test() {
        printf("constructor\n");
    };

    Test(const Test &) {
        printf("copy constructor\n");
    }

    Test(Test && m) {
        printf("move constructor\n");
    }

    ~Test() {
        printf("destruct \n");
    }

};
int main() {
    promise::any a(Test{});
//    输出
//    constructor
//    copy constructor
//    destruct
//    destruct
}

C++17 的std::any是正常的，输出

constructor
move constructor
destruct 
destruct 

看起来是holder类没有对右值构造进行重载。

template<typename ValueType>
    class holder : public placeholder {
    public: // structors
        holder(const ValueType & value)
            : held(value) {
        }

    public: // queries
        virtual type_index type() const {
            return type_id<ValueType>();
        }

        virtual placeholder * clone() const {
            return new holder(held);
        }

        virtual any call(const any &arg) const {
            return any_call(held, arg);
        }
    public: // representation
        ValueType held;
    private: // intentionally left unimplemented
        holder & operator=(const holder &);
    };

test0.cpp中有如下示例

.then([&next](){
        output_func_name();
        next= newPromise([](Defer d) {
            output_func_name();
            //尝试调用d.resolve(1, 'c');
        });
        //尝试调用 next.resolve();，或next.resolve(1, 'c');
        //Will call next.resole() or next.reject() later
        //throw 33;
        //next.reject(55, 66);
        return next;
    })

如果增加next.resolve();或者d.resolve(); 会产生bad_any_cast异常，导致promiseHolder->state_ = TaskState::kRejected，在析构时会走到全局异常handler中。

我想通过创建一个新的newPromise的方式，内部切线程异步处理完成后再回调到下个then，这样看起来会有问题。