diff --git a/CMakeLists.txt b/CMakeLists.txt
index a7f532c..ddd9169 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,6 +28,7 @@ list(APPEND closure_src
         closure/placeholders.hpp
         closure/util.hpp
         closure/bind.hpp
+        closure/trivial_tuple.hpp
         )
 
 add_executable(closure_test
diff --git a/README.md b/README.md
index bd97173..f8e8491 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 [![macOS Status](https://github.com/coyorkdow/closure/actions/workflows/macos.yml/badge.svg)](https://github.com/coyorkdow/closure/actions/workflows/macos.yml)
 [![C++ Standard](https://img.shields.io/badge/cpp14-minimum%20required-success?logo=cplusplus)](https://en.cppreference.com/w/cpp/14)
 
-Closure is header-only. To use Closure, simply copy `closure.hpp` and dicectory `closure` into your project.
+Closure is header-only. To use Closure, simply copy `closure.hpp` and dicectory `closure` into your project, and don't forget `#include "closure.hpp"`.
 
 ## Features
 
@@ -214,6 +214,6 @@ Since `closure::Any` means any type, you can assign `c` to any other closure wit
 ```C++
 // it's ok that the 4th parameter is float type, because float can implicitly convert to int
 Closure<int(int, int, std::string, float)> c2(lambda, PlaceHolder<1>(), PlaceHolder<3>());
-c2 = closure;
+c2 = c;
 c2(1, 2, "3", 4.2); // result is 6
 ```
diff --git a/closure.hpp b/closure.hpp
index e774c3c..422930f 100644
--- a/closure.hpp
+++ b/closure.hpp
@@ -12,6 +12,7 @@
 #include "closure/bind.hpp"
 #include "closure/placeholders.hpp"
 #include "closure/traits.hpp"
+#include "closure/trivial_tuple.hpp"
 
 namespace closure {
 
@@ -96,7 +97,7 @@ template <class... Args>
 struct MaybeStores {
  public:
   static constexpr bool value = placeholders::HasNonGetter<ArgList<Args...>>::value;
-  using type = std::conditional_t<value, decltype(std::make_tuple(std::declval<Args>()...)), std::tuple<>>;
+  using type = std::conditional_t<value, tuple::TrivialTuple<std::decay_t<Args>...>, tuple::TrivialTuple<>>;
 };
 
 // Overload for function pointer and functor
@@ -117,7 +118,7 @@ class ClosureImpl<R(Args...), Callable, ArgList<StoredArgs...>> : public Closure
 
  public:
   using callee_type = Callable;
-  using stored_types = decltype(std::make_tuple(std::declval<StoredArgs>()...)); /*std::tuple<StoredArgs...>*/
+  using stored_types = tuple::TrivialTuple<std::decay_t<StoredArgs>...>;
   using maybe_stores = MaybeStores<StoredArgs...>;
   static_assert(!maybe_stores::value || std::is_same<stored_types, typename maybe_stores::type>::value,
                 "maybe stored type is not same as the stored_types");
@@ -176,7 +177,7 @@ class ClosureImpl<R(Args...), Callable, ArgList<StoredArgs...>> : public Closure
 
   template <class MaybeHasPlaceHolder, std::enable_if_t<!MaybeHasPlaceHolder::value, int> = 0, std::size_t... I>
   typename base::result_type InvokeHelper(std::index_sequence<I...>, Args&&... args) {
-    return invoke::INVOKE(callable_, std::get<I>(static_cast<stored_types&>(*this))..., std::forward<Args>(args)...);
+    return invoke::INVOKE(callable_, tuple::get<I>(static_cast<stored_types&>(*this))..., std::forward<Args>(args)...);
   }
 
   callee_type callable_;
@@ -464,25 +465,33 @@ class Closure<R(Args...)> {
 };
 
 // MakeClosure for function pointer, remove cv-qualifier and noexcept
+
 template <class R, class... Args, class... Bounds,
           std::enable_if_t<!placeholders::HasPlaceHolder<ArgList<Bounds...>>::value, int> = 0>
-auto MakeClosure(R (*fptr)(Args...), Bounds&&... bound_args) {
+auto MakeClosure_ClosureImplType(R (*fptr)(Args...), Bounds&&... bound_args) {
   using closure_args = closureimpl::RemovePrefixWeakT<ArgList<Bounds...>, ArgList<Args...>>;
-  using closure_res_t = typename std::remove_pointer_t<decltype(closureimpl::MakeClosureImpl<R>(
-      nullptr, closure_args{}, fptr, std::forward<Bounds>(bound_args)...))>::closure_type;
-  return Closure<closure_res_t>(fptr, std::forward<Bounds>(bound_args)...);
+  using type =
+      decltype(closureimpl::MakeClosureImpl<R>(nullptr, closure_args{}, fptr, std::forward<Bounds>(bound_args)...));
+  return (type)(nullptr);
 }
 
 template <class R, class... Args, class... Bounds,
           std::enable_if_t<placeholders::HasPlaceHolder<ArgList<Bounds...>>::value, int> = 0>
-auto MakeClosure(R (*fptr)(Args...), Bounds&&... bound_args) {
+auto MakeClosure_ClosureImplType(R (*fptr)(Args...), Bounds&&... bound_args) {
   using bounds_l = ArgList<Bounds...>;
   using args_l = ArgList<Args...>;
   using replaced_types = closureimpl::ReplacePlaceHoldersWithGettersT<bounds_l, args_l>;
   using closure_args = ConcatT<typename closureimpl::ReplacePlaceHoldersWithGetters<bounds_l, args_l>::agents_prototype,
                                closureimpl::RemovePrefixWeakT<bounds_l, args_l>>;
-  using closure_res_t = typename std::remove_pointer_t<decltype(closureimpl::MakeClosureImpl<R>(
-      nullptr, closure_args{}, replaced_types{}, fptr, std::forward<Bounds>(bound_args)...))>::closure_type;
+  using type = decltype(closureimpl::MakeClosureImpl<R>(nullptr, closure_args{}, replaced_types{}, fptr,
+                                                        std::forward<Bounds>(bound_args)...));
+  return (type)(nullptr);
+}
+
+template <class R, class... Args, class... Bounds>
+auto MakeClosure(R (*fptr)(Args...), Bounds&&... bound_args) {
+  using impl_type = decltype(MakeClosure_ClosureImplType(fptr, std::forward<Bounds>(bound_args)...));
+  using closure_res_t = typename std::remove_pointer_t<impl_type>::closure_type;
   return Closure<closure_res_t>(fptr, std::forward<Bounds>(bound_args)...);
 }
 
@@ -494,30 +503,36 @@ template <class Functor, class... Bounds,
           std::enable_if_t<traits::IsSimpleFunctor<std::remove_reference_t<Functor>>::value &&
                                !placeholders::HasPlaceHolder<ArgList<Bounds...>>::value,
                            int> = 0>
-auto MakeClosure(Functor&& functor, Bounds&&... bound_args) {
+auto MakeClosure_ClosureImplType(Functor&& functor, Bounds&&... bound_args) {
   using functor_traits = traits::SimpleFunctorTraits<std::remove_reference_t<Functor>>;
-  using closure_res_t =
-      typename std::remove_pointer_t<decltype(closureimpl::MakeClosureImpl<typename functor_traits::return_type>(
-          nullptr, typename functor_traits::args_type{}, std::forward<Functor>(functor),
-          std::forward<Bounds>(bound_args)...))>::closure_type;
-  return Closure<closure_res_t>(std::forward<Functor>(functor), std::forward<Bounds>(bound_args)...);
+  using type = decltype(closureimpl::MakeClosureImpl<typename functor_traits::return_type>(
+      nullptr, typename functor_traits::args_type{}, std::forward<Functor>(functor),
+      std::forward<Bounds>(bound_args)...));
+  return (type)(nullptr);
 }
 
 template <class Functor, class... Bounds,
           std::enable_if_t<traits::IsSimpleFunctor<std::remove_reference_t<Functor>>::value &&
                                placeholders::HasPlaceHolder<ArgList<Bounds...>>::value,
                            int> = 0>
-auto MakeClosure(Functor&& functor, Bounds&&... bound_args) {
+auto MakeClosure_ClosureImplType(Functor&& functor, Bounds&&... bound_args) {
   using functor_traits = traits::SimpleFunctorTraits<std::remove_reference_t<Functor>>;
   using bounds_l = ArgList<Bounds...>;
   using args_l = typename functor_traits::args_type;
   using replaced_types = closureimpl::ReplacePlaceHoldersWithGettersT<bounds_l, args_l>;
   using closure_args = ConcatT<typename closureimpl::ReplacePlaceHoldersWithGetters<bounds_l, args_l>::agents_prototype,
                                closureimpl::RemovePrefixWeakT<bounds_l, args_l>>;
-  using closure_res_t =
-      typename std::remove_pointer_t<decltype(closureimpl::MakeClosureImpl<typename functor_traits::return_type>(
-          nullptr, closure_args{}, replaced_types{}, std::forward<Functor>(functor),
-          std::forward<Bounds>(bound_args)...))>::closure_type;
+  using type = decltype(closureimpl::MakeClosureImpl<typename functor_traits::return_type>(
+      nullptr, closure_args{}, replaced_types{}, std::forward<Functor>(functor), std::forward<Bounds>(bound_args)...));
+  return (type)(nullptr);
+}
+
+template <class Functor, class... Bounds,
+          std::enable_if_t<traits::IsSimpleFunctor<std::remove_reference_t<Functor>>::value, int> = 0>
+auto MakeClosure(Functor&& functor, Bounds&&... bound_args) {
+  using impl_type =
+      decltype(MakeClosure_ClosureImplType(std::forward<Functor>(functor), std::forward<Bounds>(bound_args)...));
+  using closure_res_t = typename std::remove_pointer_t<impl_type>::closure_type;
   return Closure<closure_res_t>(std::forward<Functor>(functor), std::forward<Bounds>(bound_args)...);
 }
 
@@ -526,22 +541,22 @@ template <class Method, class... Bounds,
           std::enable_if_t<std::is_member_function_pointer<Method>::value &&
                                !placeholders::HasPlaceHolder<ArgList<Bounds...>>::value,
                            int> = 0>
-auto MakeClosure(Method method, Bounds&&... bound_args) {
+auto MakeClosure_ClosureImplType(Method method, Bounds&&... bound_args) {
   using mfp_traits = traits::MemberFunctionPointerTraits<Method>;
   using class_type = typename mfp_traits::class_type;
   using args_type = typename mfp_traits::args_type;
   using return_type = typename mfp_traits::return_type;
   using closure_args = closureimpl::RemovePrefixWeakT<ArgList<Bounds...>, ConcatT<ArgList<class_type*>, args_type>>;
-  using closure_res_t = typename std::remove_pointer_t<decltype(closureimpl::MakeClosureImpl<return_type>(
-      nullptr, closure_args{}, method, std::forward<Bounds>(bound_args)...))>::closure_type;
-  return Closure<closure_res_t>(method, std::forward<Bounds>(bound_args)...);
+  using type = decltype(closureimpl::MakeClosureImpl<return_type>(nullptr, closure_args{}, method,
+                                                                  std::forward<Bounds>(bound_args)...));
+  return (type)(nullptr);
 }
 
 template <class Method, class... Bounds,
           std::enable_if_t<std::is_member_function_pointer<Method>::value &&
                                placeholders::HasPlaceHolder<ArgList<Bounds...>>::value,
                            int> = 0>
-auto MakeClosure(Method method, Bounds&&... bound_args) {
+auto MakeClosure_ClosureImplType(Method method, Bounds&&... bound_args) {
   using mfp_traits = traits::MemberFunctionPointerTraits<Method>;
   using bounds_l = ArgList<Bounds...>;
   using class_type = typename mfp_traits::class_type;
@@ -550,8 +565,15 @@ auto MakeClosure(Method method, Bounds&&... bound_args) {
   using replaced_types = closureimpl::ReplacePlaceHoldersWithGettersT<bounds_l, args_l>;
   using closure_args = ConcatT<typename closureimpl::ReplacePlaceHoldersWithGetters<bounds_l, args_l>::agents_prototype,
                                closureimpl::RemovePrefixWeakT<bounds_l, args_l>>;
-  using closure_res_t = typename std::remove_pointer_t<decltype(closureimpl::MakeClosureImpl<return_type>(
-      nullptr, closure_args{}, replaced_types{}, method, std::forward<Bounds>(bound_args)...))>::closure_type;
+  using type = decltype(closureimpl::MakeClosureImpl<return_type>(nullptr, closure_args{}, replaced_types{}, method,
+                                                                  std::forward<Bounds>(bound_args)...));
+  return type(nullptr);
+}
+
+template <class Method, class... Bounds, std::enable_if_t<std::is_member_function_pointer<Method>::value, int> = 0>
+auto MakeClosure(Method method, Bounds&&... bound_args) {
+  using impl_type = decltype(MakeClosure_ClosureImplType(method, std::forward<Bounds>(bound_args)...));
+  using closure_res_t = typename std::remove_pointer_t<impl_type>::closure_type;
   return Closure<closure_res_t>(method, std::forward<Bounds>(bound_args)...);
 }
 
diff --git a/closure/placeholders.hpp b/closure/placeholders.hpp
index cde6722..08e9e9f 100644
--- a/closure/placeholders.hpp
+++ b/closure/placeholders.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "closure/traits.hpp"
+#include "closure/trivial_tuple.hpp"
 #include "closure/util.hpp"
 
 namespace closure {
@@ -151,15 +152,15 @@ template <size_t I, class AgentsTuple, class... Os>
 struct HasNonGetter<ArgList<Getter<AgentsTuple, I>, Os...>> : HasNonGetter<ArgList<Os...>> {};
 
 template <size_t I, class Tuple, class Agents,
-          std::enable_if_t<IsGetter<std::decay_t<decltype(std::get<I>(std::declval<Tuple>()))>>::value, int> = 0>
+          std::enable_if_t<IsGetter<std::decay_t<decltype(tuple::get<I>(std::declval<Tuple>()))>>::value, int> = 0>
 decltype(auto) TryMapAndGet(Tuple&& tuple, Agents&& agents) noexcept {
-  return std::get<I>(std::forward<Tuple>(tuple)).Get(agents);
+  return tuple::get<I>(std::forward<Tuple>(tuple)).Get(agents);
 }
 
 template <size_t I, class Tuple, class Agents,
-          std::enable_if_t<!IsGetter<std::decay_t<decltype(std::get<I>(std::declval<Tuple>()))>>::value, int> = 0>
+          std::enable_if_t<!IsGetter<std::decay_t<decltype(tuple::get<I>(std::declval<Tuple>()))>>::value, int> = 0>
 decltype(auto) TryMapAndGet(Tuple&& tuple, Agents&&) noexcept {
-  return std::get<I>(std::forward<Tuple>(tuple));
+  return tuple::get<I>(std::forward<Tuple>(tuple));
 }
 
 };  // namespace placeholders
diff --git a/closure/traits.hpp b/closure/traits.hpp
index bf1a018..a65031e 100644
--- a/closure/traits.hpp
+++ b/closure/traits.hpp
@@ -100,55 +100,6 @@ using std::void_t;
 
 namespace traits {
 
-template <class Tp>
-struct IsFunctionOrPointerToFunction
-    : std::integral_constant<bool, std::is_function<Tp>::value || std::is_function<std::remove_pointer_t<Tp>>::value> {
-};
-
-template <class Tp, void_t<decltype(&Tp::operator->), decltype(&Tp::operator*)>* = nullptr>
-auto IsDereferencableImpl(int) -> std::integral_constant<
-    bool, std::is_pointer<decltype(std::declval<Tp>().operator->())>::value &&
-              std::is_reference<decltype(std::declval<Tp>().operator*())>::value &&
-              std::is_same<std::remove_pointer_t<decltype(std::declval<Tp>().operator->())>,
-                           std::remove_reference_t<decltype(std::declval<Tp>().operator*())>>::value>;
-
-template <class Tp>
-auto IsDereferencableImpl(...) -> std::is_pointer<Tp>;
-
-template <class Ptr>
-struct IsDereferencable : decltype(IsDereferencableImpl<Ptr>(0)) {};
-
-template <class Dereferencable, class Method, class... Args>
-auto TryCallMethod(int, Dereferencable&&, Method&&, Args&&...)
-    -> decltype(((*std::declval<Dereferencable>()).*std::declval<Method>())(std::declval<Args>()...), std::true_type{});
-
-auto TryCallMethod(float, ...) -> std::false_type;
-
-template <class Dereferencable, class Method>
-struct CanUsePointerToMemberFunction : std::false_type {};
-
-template <class Dereferencable, class R, class Class, class... Args>
-struct CanUsePointerToMemberFunction<Dereferencable, R (Class::*)(Args...)>
-    : decltype(TryCallMethod(0, std::declval<Dereferencable>(), std::declval<R (Class::*)(Args...)>(),
-                             std::declval<Args>()...)) {};
-
-template <class Dereferencable, class R, class Class, class... Args>
-struct CanUsePointerToMemberFunction<Dereferencable, R (Class::*)(Args...) const>
-    : decltype(TryCallMethod(0, std::declval<Dereferencable>(), std::declval<R (Class::*)(Args...) const>(),
-                             std::declval<Args>()...)) {};
-
-#if !(__cplusplus < 201703L)
-template <class Dereferencable, class R, class Class, class... Args>
-struct CanUsePointerToMemberFunction<Dereferencable, R (Class::*)(Args...) noexcept>
-    : decltype(TryCallMethod(0, std::declval<Dereferencable>(), std::declval<R (Class::*)(Args...) noexcept>(),
-                             std::declval<Args>()...)) {};
-
-template <class Dereferencable, class R, class Class, class... Args>
-struct CanUsePointerToMemberFunction<Dereferencable, R (Class::*)(Args...) const noexcept>
-    : decltype(TryCallMethod(0, std::declval<Dereferencable>(), std::declval<R (Class::*)(Args...) const noexcept>(),
-                             std::declval<Args>()...)) {};
-#endif
-
 template <class Op>
 struct MemberFunctionPointerTraits {};
 
@@ -166,6 +117,20 @@ struct MemberFunctionPointerTraits<R (Class::*)(Args...) const> {
   using args_type = ArgList<Args...>;
 };
 
+template <class R, class Class, class... Args>
+struct MemberFunctionPointerTraits<R (Class::*)(Args...) volatile> {
+  using class_type = Class;
+  using return_type = R;
+  using args_type = ArgList<Args...>;
+};
+
+template <class R, class Class, class... Args>
+struct MemberFunctionPointerTraits<R (Class::*)(Args...) const volatile> {
+  using class_type = Class;
+  using return_type = R;
+  using args_type = ArgList<Args...>;
+};
+
 #if !(__cplusplus < 201703L)
 template <class R, class Class, class... Args>
 struct MemberFunctionPointerTraits<R (Class::*)(Args...) noexcept> {
@@ -180,6 +145,20 @@ struct MemberFunctionPointerTraits<R (Class::*)(Args...) const noexcept> {
   using return_type = R;
   using args_type = ArgList<Args...>;
 };
+
+template <class R, class Class, class... Args>
+struct MemberFunctionPointerTraits<R (Class::*)(Args...) volatile noexcept> {
+  using class_type = Class;
+  using return_type = R;
+  using args_type = ArgList<Args...>;
+};
+
+template <class R, class Class, class... Args>
+struct MemberFunctionPointerTraits<R (Class::*)(Args...) const volatile noexcept> {
+  using class_type = Class;
+  using return_type = R;
+  using args_type = ArgList<Args...>;
+};
 #endif
 
 // Traits for simple functor.
diff --git a/closure/trivial_tuple.hpp b/closure/trivial_tuple.hpp
new file mode 100644
index 0000000..7230649
--- /dev/null
+++ b/closure/trivial_tuple.hpp
@@ -0,0 +1,98 @@
+//
+// Created by Youtao Guo on 2023/2/18.
+//
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace closure {
+
+namespace tuple {
+
+template <size_t I, class Tp>
+struct Component {
+  static_assert(std::is_same<Tp, std::decay_t<Tp>>::value, "type Tp is not a decayed type");
+
+ protected:
+  constexpr Component() = default;
+  template <class Up, std::enable_if_t<!std::is_same<std::decay_t<Up>, Component>::value, int> = 0>
+  constexpr explicit Component(Up&& v) : value(std::forward<Up>(v)) {}
+
+  Tp value;
+};
+
+static_assert(std::is_trivially_copyable<Component<123, int>>::value, "");
+
+template <class Index, class... Tp>
+class TupleImpl;
+
+template <size_t... Is, class... Tp>
+class TupleImpl<std::index_sequence<Is...>, Tp...> : private Component<Is, Tp>... {
+  template <size_t F, size_t I, class Tp_, class... Tps_>
+  struct ElementTypeImpl {
+    static_assert(I < sizeof...(Is), "index out of bound");
+    using type = typename ElementTypeImpl<F + 1, I, Tps_...>::type;
+  };
+
+  template <size_t I, class Tp_, class... Tps_>
+  struct ElementTypeImpl<I, I, Tp_, Tps_...> {
+    using type = Tp_;
+  };
+
+ protected:
+  template <size_t I>
+  struct ElementType {
+    using type = typename ElementTypeImpl<0, I, Tp...>::type;
+  };
+
+  constexpr TupleImpl() = default;
+
+  template <class... Ups>
+  constexpr explicit TupleImpl(Ups&&... ups) : Component<Is, Tp>(std::forward<Ups>(ups))... {}
+
+  template <size_t I>
+  constexpr const typename ElementType<I>::type& Get() const noexcept {
+    return Component<I, typename ElementType<I>::type>::value;
+  }
+
+  template <size_t I>
+  typename ElementType<I>::type& Get() noexcept {
+    return Component<I, typename ElementType<I>::type>::value;
+  }
+};
+
+template <class... Tps>
+class TrivialTuple : private TupleImpl<std::index_sequence_for<Tps...>, Tps...> {
+  using base = TupleImpl<std::index_sequence_for<Tps...>, Tps...>;
+
+ public:
+  constexpr TrivialTuple() = default;
+
+  template <class... Ups>
+  constexpr explicit TrivialTuple(Ups&&... ups) : base(std::forward<Ups>(ups)...) {}
+
+  using base::Get;
+};
+
+static_assert(std::is_trivially_copyable<TrivialTuple<>>::value, "");
+static_assert(std::is_trivially_copyable<TrivialTuple<int>>::value, "");
+static_assert(std::is_trivially_copyable<TrivialTuple<int, double, std::string*>>::value, "");
+
+using std::get;
+
+template <size_t I, class... Tps>
+constexpr decltype(auto) get(const TrivialTuple<Tps...>& tuple) noexcept {
+  return tuple.template Get<I>();
+}
+
+template <size_t I, class... Tps>
+constexpr decltype(auto) get(TrivialTuple<Tps...>& tuple) noexcept {
+  return tuple.template Get<I>();
+}
+
+}  // namespace tuple
+
+}  // namespace closure
\ No newline at end of file
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index fd38a0d..fa7c1f9 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -21,6 +21,7 @@ list(APPEND closure_src
         ../closure/placeholders.hpp
         ../closure/util.hpp
         ../closure/bind.hpp
+        ../closure/trivial_tuple.hpp
         )
 
 add_executable(example
diff --git a/example/example.cpp b/example/example.cpp
index 7f7f8eb..aaa626f 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -1,3 +1,4 @@
+#include <cassert>
 #include <iostream>
 
 #include "closure.hpp"
diff --git a/test/test.cpp b/test/test.cpp
index 11526fd..7b032f8 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -302,17 +302,6 @@ TEST(TestAnyType, Any) {
   test("123");
 }
 
-TEST(TestClosure, EmptyBaseOptimize) {
-  using c1 = closureimpl::ClosureImpl<void(), void (*)(), ArgList<>>;
-  static_assert(sizeof(c1) == 8, "");
-  using agents = std::tuple<placeholders::Agent<int>, placeholders::Agent<int>>;
-  using c2 = closureimpl::ClosureImpl<void(), void (*)(int, int),
-                                      ArgList<placeholders::Getter<agents, 1>, placeholders::Getter<agents, 0>>>;
-  static_assert(sizeof(c2) == 8, "");
-  using c3 = Closure<int(int, int)>;
-  static_assert(sizeof(c3) == 32, "");
-}
-
 std::size_t sum(const int& v1, double v2, int v3, int v4) noexcept { return v1 + v2 + v3 + v4; }
 
 int forwarding_test(std::unique_ptr<int> p) noexcept { return *p; }
@@ -356,6 +345,31 @@ TEST(TestValidator, InvokeMemberFunction) {
   static_assert(std::is_same<typename v1::invoke_result, int>::value, "");
 }
 
+TEST(TestClosure, EmptyBaseOptimize) {
+  using c1 = closureimpl::ClosureImpl<void(), void (*)(), ArgList<>>;
+  static_assert(sizeof(c1) == 8, "");
+  using agents = std::tuple<placeholders::Agent<int>, placeholders::Agent<int>>;
+  using c2 = closureimpl::ClosureImpl<void(), void (*)(int, int),
+                                      ArgList<placeholders::Getter<agents, 1>, placeholders::Getter<agents, 0>>>;
+  static_assert(sizeof(c2) == 8, "");
+  using c3 = Closure<int(int, int)>;
+  static_assert(sizeof(c3) == 32, "");
+}
+
+TEST(TestClosure, TrivialTuple) {
+  static_assert(std::is_trivially_copyable<placeholders::Agent<int>>::value, "");
+  using c1 = closureimpl::ClosureImpl<void(), void (*)(), ArgList<>>;
+  static_assert(std::is_trivially_copyable<c1>::value, "");
+
+  using c2 = std::remove_pointer_t<decltype(MakeClosure_ClosureImplType(test_ref, 1))>;
+  static_assert(closureimpl::soo::IsSmallObject<c2>::value, "");
+
+  using c3 = std::remove_pointer_t<decltype(MakeClosure_ClosureImplType(sum, PlaceHolder<0>(), PlaceHolder<1>(), 1))>;
+  static_assert(closureimpl::soo::IsSmallObject<c3>::value, "");
+  using c3tuple = typename c3::stored_types;
+  static_assert(sizeof(c3tuple) == 8, "");
+}
+
 TEST(TestClosure, FunctionPointer) {
   auto closure1 = MakeClosure(sum, 1);
   static_assert(std::is_same<decltype(closure1), Closure<std::size_t(double, int, int)>>::value, "");
@@ -481,7 +495,6 @@ class TestClassBindMethod {
 TEST(TestClosure, Method) {
   TestClassBindMethod cl;
   static_assert(std::is_member_function_pointer<decltype(&TestClassBindMethod::ResIntArg0)>::value, "");
-  static_assert(traits::IsDereferencable<std::unique_ptr<TestClassBindMethod>>::value, "");
 
   auto closure1 = MakeClosure(&TestClassBindMethod::ResIntArg0, &cl);
   EXPECT_EQ(closure1(), 0);
@@ -540,9 +553,10 @@ TEST(TestClosure, NonSimpleFunctor) {
   EXPECT_EQ(closure2(1, 2), 3);
 
   struct Simple {
-    int operator()(int a, int b) const { return a + b; }
+    int operator()(int a, int b) const volatile { return a + b; }
   };
   closure2 = MakeClosure(Simple{});  // ok
+  EXPECT_EQ(closure2(7, 8), 15);
 }
 
 TEST(TestClosureWithPlaceHolders, FunctionPointer) {