diff --git a/CMakeLists.txt b/CMakeLists.txt
index 007d75a07..3b6e9a7a3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,6 +69,11 @@ else()
         -D__STDC_LIMIT_MACROS
         -g
         )
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        list(APPEND CXX_FLAGS -Wno-uninitialized)
+    else()
+        list(APPEND CXX_FLAGS -Wno-maybe-uninitialized)
+    endif()
 endif()
 
 set(IS_ACC OFF CACHE INTERNAL "Whether the current compiler is ACC")
diff --git a/async_simple/FutureState.h b/async_simple/FutureState.h
index 9cac785fa..7f4958399 100644
--- a/async_simple/FutureState.h
+++ b/async_simple/FutureState.h
@@ -27,8 +27,8 @@
 #include <thread>
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
-#include "async_simple/MoveWrapper.h"
 #include "async_simple/Try.h"
+#include "async_simple/util/move_only_function.h"
 
 namespace async_simple {
 
@@ -62,7 +62,7 @@ constexpr State operator&(State lhs, State rhs) {
 template <typename T>
 class FutureState {
 private:
-    using Continuation = std::function<void(Try<T>&& value)>;
+    using Continuation = util::move_only_function<void(Try<T>&& value)>;
 
 private:
     // A helper to help FutureState to count the references to guarantee
@@ -228,11 +228,10 @@ class FutureState {
     void setContinuation(F&& func) {
         logicAssert(!hasContinuation(),
                     "FutureState already has a continuation");
-        MoveWrapper<F> lambdaFunc(std::move(func));
-        new (&_continuation) Continuation([lambdaFunc](Try<T>&& v) mutable {
-            auto& lambda = lambdaFunc.get();
-            lambda(std::forward<Try<T>>(v));
-        });
+        new (&_continuation)
+            Continuation([func = std::move(func)](Try<T>&& v) mutable {
+                func(std::forward<Try<T>>(v));
+            });
 
         auto state = _state.load(std::memory_order_acquire);
         switch (state) {
diff --git a/async_simple/LocalState.h b/async_simple/LocalState.h
index f205a045f..297de380c 100644
--- a/async_simple/LocalState.h
+++ b/async_simple/LocalState.h
@@ -27,7 +27,6 @@
 #include <utility>
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
-#include "async_simple/MoveWrapper.h"
 #include "async_simple/Try.h"
 
 namespace async_simple {
diff --git a/async_simple/MoveWrapper.h b/async_simple/MoveWrapper.h
deleted file mode 100644
index 698039a3d..000000000
--- a/async_simple/MoveWrapper.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ASYNC_SIMPLE_MOVEWRAPPER_H
-#define ASYNC_SIMPLE_MOVEWRAPPER_H
-
-#include <exception>
-#include "async_simple/Common.h"
-
-namespace async_simple {
-
-// std::function requre copyConstructable, hence we provide MoveWrapper perform
-// copy as move.
-template <typename T>
-class MoveWrapper {
-public:
-    MoveWrapper() = default;
-    MoveWrapper(T&& value) : _value(std::move(value)) {}
-
-    MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
-    MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
-
-    MoveWrapper& operator=(const MoveWrapper&) = delete;
-    MoveWrapper& operator=(MoveWrapper&&) = delete;
-
-    T& get() { return _value; }
-    const T& get() const { return _value; }
-
-    ~MoveWrapper() {}
-
-private:
-    mutable T _value;
-};
-
-}  // namespace async_simple
-
-#endif  // ASYNC_SIMPLE_MOVEWRAPPER_H
diff --git a/async_simple/util/move_only_function.h b/async_simple/util/move_only_function.h
new file mode 100644
index 000000000..a0f51dd33
--- /dev/null
+++ b/async_simple/util/move_only_function.h
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 2022, Alibaba Group Holding Limited;
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* This file implements a simple condition variable. This is used as a
+ * low level component in async_simple. Users shouldn't use this directly.
+ */
+#ifndef ASYNC_SIMPLE_UTIL_MOVE_ONLY_FUNCTION_H
+#define ASYNC_SIMPLE_UTIL_MOVE_ONLY_FUNCTION_H
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+namespace async_simple::util {
+
+template <typename ResultType, typename RetType,
+          bool = std::is_void<RetType>::value, typename = void>
+struct RetTypeCheck : std::false_type {};
+
+template <typename ResultType, typename RetType>
+struct RetTypeCheck<ResultType, RetType, true,
+                    std::void_t<typename ResultType::type>> : std::true_type {};
+
+// check the implicit conversion to R.
+template <typename ResultType, typename RetType>
+struct RetTypeCheck<ResultType, RetType, false,
+                    std::void_t<typename ResultType::type>> : std::true_type {
+private:
+    static typename ResultType::type _S_get();
+
+    template <typename T>
+    static void _S_conv(T);
+
+    template <typename T, typename = decltype(_S_conv<T>(_S_get()))>
+    static std::true_type _S_test(int);
+
+    template <typename T>
+    static std::false_type _S_test(...);
+
+public:
+    using type = decltype(_S_test<RetType>(1));
+};
+
+class _undefined_class;
+
+union _no_copy_types {
+    void* _m_object;
+    const void* _m_const_object;
+    void (*_m_function_pointer)();
+    void (_undefined_class::*_m_member_pointer)();
+};
+
+union [[gnu::may_alias]] _any_data {
+    void* _m_access() { return &_m_pod_data[0]; }
+
+    const void* _m_access() const { return &_m_pod_data[0]; }
+
+    template <typename T>
+    T& _m_access() {
+        return *static_cast<T*>(_m_access());
+    }
+
+    template <typename T>
+    const T& _m_access() const {
+        return *static_cast<const T*>(_m_access());
+    }
+
+    _no_copy_types _m_unused;
+    char _m_pod_data[sizeof(_no_copy_types)];
+};
+
+enum class _manager_operation : uint8_t {
+    _destroy_functor,
+};
+
+template <typename Signature>
+class move_only_function;
+
+class _function_base {
+public:
+    static constexpr size_t _m_max_size = sizeof(_no_copy_types);
+    static constexpr size_t _m_max_align = alignof(_no_copy_types);
+
+    template <typename Functor>
+    class _base_manager {
+    protected:
+        static const bool _stored_locally =
+            std::is_trivially_copyable_v<Functor> &&
+            sizeof(Functor) <= _m_max_size &&
+            alignof(Functor) <= _m_max_align &&
+            (_m_max_align % alignof(Functor) == 0);
+
+        typedef std::integral_constant<bool, _stored_locally> _local_storage;
+
+        static Functor* _m_get_pointer(const _any_data& _source) {
+            if constexpr (_stored_locally) {
+                const Functor& f = _source._m_access<Functor>();
+                return const_cast<Functor*>(std::addressof(f));
+            }
+            return _source._m_access<Functor*>();
+        }
+
+        static void _m_destroy(_any_data& _victim, std::true_type) {
+            _victim._m_access<Functor>().~Functor();
+        }
+
+        static void _m_destroy(_any_data& _victim, std::false_type) {
+            delete _victim._m_access<Functor*>();
+        }
+
+    public:
+        static void _m_manager(_any_data& _dest, const _any_data& _source,
+                               _manager_operation _op) {
+            switch (_op) {
+                case _manager_operation::_destroy_functor:
+                    _m_destroy(_dest, _local_storage());
+                    break;
+            }
+        }
+
+        static void _m_init_functor(_any_data& _functor, Functor&& _f) {
+            _m_init_functor(_functor, std::move(_f), _local_storage());
+        }
+
+        static void _m_init_functor(_any_data& _functor, const Functor& _f) {
+            _m_init_functor(_functor, _f, _local_storage());
+        }
+
+        template <typename Signature>
+        static bool _m_not_empty_function(
+            const move_only_function<Signature>& f) {
+            return static_cast<bool>(f);
+        }
+
+        template <typename T>
+        static bool _m_not_empty_function(T* fp) {
+            return fp != nullptr;
+        }
+
+        template <typename Class, typename T>
+        static bool _m_not_empty_function(T Class::*mp) {
+            return mp != nullptr;
+        }
+
+        template <typename T>
+        static bool _m_not_empty_function(const T&) {
+            return true;
+        }
+
+    private:
+        static void _m_init_functor(_any_data& functor, Functor&& f,
+                                    std::true_type) {
+            ::new (functor._m_access()) Functor(std::move(f));
+        }
+
+        static void _m_init_functor(_any_data& functor, Functor&& f,
+                                    std::false_type) {
+            functor._m_access<Functor*>() = new Functor(std::move(f));
+        }
+
+        static void _m_init_functor(_any_data& functor, const Functor& f,
+                                    std::true_type) {
+            ::new (functor._m_access()) Functor(f);
+        }
+
+        static void _m_init_functor(_any_data& functor, const Functor& f,
+                                    std::false_type) {
+            functor._m_access<Functor*>() = new Functor(f);
+        }
+    };
+
+    _function_base() : _m_manager(nullptr) {}
+
+    ~_function_base() {
+        if (_m_manager) {
+            _m_manager(_m_functor, _m_functor,
+                       _manager_operation::_destroy_functor);
+        }
+    }
+
+    bool _m_empty() const { return !_m_manager; }
+
+    using manager_type = void (*)(_any_data&, const _any_data&,
+                                  _manager_operation);
+
+    _any_data _m_functor;
+    manager_type _m_manager;
+};
+
+template <typename Signature, typename Functor>
+class FunctionHandler;
+
+template <typename Res, typename Functor, typename... ArgTypes>
+class FunctionHandler<Res(ArgTypes...), Functor>
+    : public _function_base::_base_manager<Functor> {
+    using BaseType = _function_base::_base_manager<Functor>;
+
+public:
+    static void _m_manager(_any_data& _dest, const _any_data& _source,
+                           _manager_operation _op) {
+        return BaseType::_m_manager(_dest, _source, _op);
+    }
+
+    static Res _m_invoke(const _any_data& _functor, ArgTypes&&... _args) {
+        if constexpr (std::is_same_v<Res, void>) {
+            std::invoke(*BaseType::_m_get_pointer(_functor),
+                        std::forward<ArgTypes>(_args)...);
+        } else {
+            return std::invoke(*BaseType::_m_get_pointer(_functor),
+                               std::forward<ArgTypes>(_args)...);
+        }
+    }
+};
+
+// Specialization for invalid types
+template <>
+class FunctionHandler<void, void> {
+public:
+    static void _m_manager(_any_data&, const _any_data&, _manager_operation) {
+        return;
+    }
+};
+
+template <typename RetType, typename... ArgTypes>
+class move_only_function<RetType(ArgTypes...)> : private _function_base {
+    template <typename Func,
+              typename Res2 = std::invoke_result<Func, ArgTypes...>>
+    struct Callable : public RetTypeCheck<Res2, RetType>::type {};
+
+    template <typename T>
+    struct Callable<move_only_function, T> : public std::false_type {};
+
+    template <typename T>
+    struct IsCStyleFunction : public std::false_type {};
+
+    template <typename Ret, typename... Args>
+    struct IsCStyleFunction<Ret (&)(Args...)> : public std::true_type {};
+
+    template <typename Cond, typename T>
+    using Requires = typename std::enable_if<Cond::value, T>::type;
+
+public:
+    using result_type = RetType;
+
+    // Default construct creates an empty function call wrapper.
+    move_only_function() noexcept : _function_base() {}
+
+    move_only_function(std::nullptr_t) noexcept : _function_base() {}
+
+    // delete copy constructor
+    move_only_function(const move_only_function&) = delete;
+
+    move_only_function(move_only_function&& other) noexcept : _function_base() {
+        other.swap(*this);
+    }
+
+    template <
+        typename Functor,
+        typename =
+            Requires<std::negation<std::is_same<
+                         std::remove_reference_t<Functor>, move_only_function>>,
+                     void>,
+        typename = Requires<std::negation<IsCStyleFunction<Functor>>, void>,
+        typename = Requires<Callable<Functor>, void>>
+    move_only_function(Functor&& f) : _function_base() {
+        using MyHandler = FunctionHandler<RetType(ArgTypes...),
+                                          std::remove_reference_t<Functor>>;
+        if (MyHandler::_m_not_empty_function(f)) {
+            MyHandler::_m_init_functor(_m_functor, std::forward<Functor>(f));
+            _m_invoker = &MyHandler::_m_invoke;
+            _m_manager = &MyHandler::_m_manager;
+        }
+    }
+
+    // fix error: invalid application of 'sizeof' to a function type
+    // [-Werror=pointer-arith]
+    template <typename Res, typename... Args>
+    move_only_function(Res (&f)(Args...)) : _function_base() {
+        using MyHandler =
+            FunctionHandler<RetType(ArgTypes...), Res (*)(Args...)>;
+        if (MyHandler::_m_not_empty_function(&f)) {
+            MyHandler::_m_init_functor(_m_functor, &f);
+            _m_invoker = &MyHandler::_m_invoke;
+            _m_manager = &MyHandler::_m_manager;
+        }
+    }
+
+    move_only_function& operator=(const move_only_function&) = delete;
+
+    move_only_function& operator=(move_only_function&& other) noexcept {
+        move_only_function(std::move(other)).swap(*this);
+        return *this;
+    }
+
+    move_only_function& operator=(std::nullptr_t) noexcept {
+        if (_m_manager) {
+            _m_manager(_m_functor, _m_functor,
+                       _manager_operation::_destroy_functor);
+            _m_manager = nullptr;
+            _m_invoker = nullptr;
+        }
+        return *this;
+    }
+
+    template <typename Functor>
+    Requires<Callable<typename std::decay<Functor>::type>, move_only_function&>
+    operator=(Functor&& f) {
+        move_only_function(std::forward<Functor>(f)).swap(*this);
+        return *this;
+    }
+
+    void swap(move_only_function& other) noexcept {
+        std::swap(_m_functor, other._m_functor);
+        std::swap(_m_manager, other._m_manager);
+        std::swap(_m_invoker, other._m_invoker);
+    }
+
+    explicit operator bool() const noexcept { return !_m_empty(); }
+
+    RetType operator()(ArgTypes... _args) const {
+        if (_m_empty()) {
+            throw std::bad_function_call();
+        }
+        return _m_invoker(_m_functor, std::forward<ArgTypes>(_args)...);
+    }
+
+private:
+    using InvokerType = RetType (*)(const _any_data&, ArgTypes&&...);
+    InvokerType _m_invoker;
+};
+
+template <typename>
+struct _move_only_function_guide_helper {};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...)> {
+    using type = Res(Args...);
+};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...)&> {
+    using type = Res(Args...);
+};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...) const> {
+    using type = Res(Args...);
+};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...) const&> {
+    using type = Res(Args...);
+};
+
+template <typename Functor,
+          typename Signature = typename _move_only_function_guide_helper<
+              decltype(&Functor::operator())>::type>
+move_only_function(Functor) -> move_only_function<Signature>;
+
+template <typename Res, typename... Args>
+inline void swap(move_only_function<Res(Args...)>& _x,
+                 move_only_function<Res(Args...)>& _y) noexcept {
+    _x.swap(_y);
+}
+
+template <typename Res, typename... Args>
+inline bool operator==(const move_only_function<Res(Args...)>& f,
+                       std::nullptr_t) noexcept {
+    return !static_cast<bool>(f);
+}
+
+}  // namespace async_simple::util
+
+#endif
diff --git a/async_simple/util/test/MoveOnlyFunctionTest.cpp b/async_simple/util/test/MoveOnlyFunctionTest.cpp
new file mode 100644
index 000000000..0f4232127
--- /dev/null
+++ b/async_simple/util/test/MoveOnlyFunctionTest.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2022, Alibaba Group Holding Limited;
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include "async_simple/util/move_only_function.h"
+
+namespace async_simple {
+
+namespace util {
+
+TEST(move_only_function, empty) {
+    move_only_function<int(int)> f;
+    EXPECT_THROW(f(2), std::bad_function_call);
+}
+
+int test_for_move_only(int i) { return i; }
+
+int test_for_move_only_2(int i) { return i + 1; }
+
+TEST(move_only_function, function) {
+    move_only_function<int(int)> f(test_for_move_only);
+    EXPECT_EQ(f(2), 2);
+    f = move_only_function<int(int)>(test_for_move_only_2);
+    EXPECT_EQ(f(2), 3);
+    f = nullptr;
+    EXPECT_EQ(f.operator bool(), false);
+    EXPECT_THROW(f(2), std::bad_function_call);
+    move_only_function<int(int)> f3(&test_for_move_only);
+    EXPECT_EQ(f3(2), 2);
+}
+
+struct TestForMoveOnlyFunction {
+    TestForMoveOnlyFunction(int i) : i_(i) {}
+
+    TestForMoveOnlyFunction(const TestForMoveOnlyFunction& other) {
+        i_ = other.i_;
+        copy_constructor_count += 1;
+    }
+
+    TestForMoveOnlyFunction(TestForMoveOnlyFunction&& other) {
+        i_ = other.i_;
+        move_cosntructor_count += 1;
+    }
+
+    TestForMoveOnlyFunction& operator=(const TestForMoveOnlyFunction& other) {
+        i_ = other.i_;
+        copy_assign_count += 1;
+        return *this;
+    }
+
+    TestForMoveOnlyFunction& operator=(TestForMoveOnlyFunction&& other) {
+        i_ = other.i_;
+        move_assign_count += 1;
+        return *this;
+    }
+
+    ~TestForMoveOnlyFunction() { destructor_count += 1; }
+
+    int i_ = 0;
+
+    int operator()() { return i_; }
+
+    static int copy_constructor_count;
+    static int copy_assign_count;
+
+    static int move_cosntructor_count;
+    static int move_assign_count;
+    static int destructor_count;
+
+    static void reset_count() {
+        copy_constructor_count = 0;
+        copy_assign_count = 0;
+        move_cosntructor_count = 0;
+        move_assign_count = 0;
+        destructor_count = 0;
+    }
+};
+
+int TestForMoveOnlyFunction::copy_constructor_count = 0;
+int TestForMoveOnlyFunction::copy_assign_count = 0;
+int TestForMoveOnlyFunction::move_cosntructor_count = 0;
+int TestForMoveOnlyFunction::move_assign_count = 0;
+int TestForMoveOnlyFunction::destructor_count = 0;
+
+TEST(move_only_function, functor) {
+    move_only_function<int()> f(TestForMoveOnlyFunction{10});
+    EXPECT_EQ(TestForMoveOnlyFunction::copy_assign_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::copy_constructor_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::move_assign_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::move_cosntructor_count, 1);
+    EXPECT_EQ(f(), 10);
+    TestForMoveOnlyFunction::reset_count();
+
+    TestForMoveOnlyFunction tmp{20};
+    move_only_function<int()> f2(tmp);
+    EXPECT_EQ(TestForMoveOnlyFunction::copy_assign_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::copy_constructor_count, 1);
+    EXPECT_EQ(TestForMoveOnlyFunction::move_assign_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::move_cosntructor_count, 0);
+    EXPECT_EQ(f2(), 20);
+    TestForMoveOnlyFunction::reset_count();
+
+    move_only_function<int()> f3(std::move(tmp));
+    EXPECT_EQ(TestForMoveOnlyFunction::copy_assign_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::copy_constructor_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::move_assign_count, 0);
+    EXPECT_EQ(TestForMoveOnlyFunction::move_cosntructor_count, 1);
+    EXPECT_EQ(f3(), 20);
+    TestForMoveOnlyFunction::reset_count();
+    f3 = nullptr;
+    EXPECT_EQ(TestForMoveOnlyFunction::destructor_count, 1);
+}
+
+TEST(move_only_function, lambda) {
+    std::unique_ptr<int> num = std::make_unique<int>(10);
+    auto lambda = [num = std::move(num)]() -> int { return *num; };
+    move_only_function<int()> f(std::move(lambda));
+    EXPECT_EQ(f(), 10);
+
+    std::unique_ptr<int> num2(new int(20));
+    auto lambda2 = [num2 = std::move(num2)]() -> int { return *num2; };
+    move_only_function<int()> f2;
+    f2 = std::move(lambda2);
+    EXPECT_EQ(f2(), 20);
+}
+
+TEST(move_only_function, std_function) {
+    std::function<int(int)> f = [](int i) { return i + i; };
+    move_only_function f2(f);
+    EXPECT_EQ(f2(2), 4);
+    f2 = std::function<int(int)>([](int i) { return i * 3; });
+    EXPECT_EQ(f2(2), 6);
+}
+
+struct TestForMemFnCalledByMoveOnlyFunction {
+    int add(int i) const { return i + 10; }
+};
+
+TEST(move_only_function, mem_fn) {
+    move_only_function<int(const TestForMemFnCalledByMoveOnlyFunction&, int)> f(
+        &TestForMemFnCalledByMoveOnlyFunction::add);
+    TestForMemFnCalledByMoveOnlyFunction obj;
+    EXPECT_EQ(f(obj, 10), 20);
+}
+
+TEST(move_only_function, ret_type_check) {
+    move_only_function<void(int)> f(test_for_move_only);
+    EXPECT_NO_THROW(f(10));
+}
+
+TEST(move_only_function, equal_check) {
+    move_only_function<void()> f;
+    EXPECT_EQ(f, nullptr);
+    EXPECT_EQ(nullptr, f);
+    move_only_function<void()> f2(nullptr);
+    EXPECT_EQ(f2, nullptr);
+    f = []() {};
+    EXPECT_NE(f, nullptr);
+    EXPECT_NE(nullptr, f);
+}
+
+}  // namespace util
+
+}  // namespace async_simple