Factory functions can use the ctor directly now.

include/scope_exit.h

     [[deprecated("Use ctor instead. Will be removed in a future v0.2.x release")]]
     scope_exit<std::decay_t<EF>> make_scope_exit(EF&& exitFunction)
     {
-        return scope_exit<std::decay_t<EF>>{std::forward<EF>(exitFunction)};
+        return scope_exit{std::forward<EF>(exitFunction)};
     }
 
 }

include/scope_fail.h

     [[deprecated("Use ctor instead. Will be removed in a future v0.2.x release")]]
     scope_fail<std::decay_t<EF>> make_scope_fail(EF&& exitFunction)
     {
-        return scope_fail<std::decay_t<EF>>{std::forward<EF>(exitFunction)};
+        return scope_fail{std::forward<EF>(exitFunction)};
     }
 
 }

include/scope_success.h

     [[deprecated("Use ctor instead. Will be removed in a future v0.2.x release")]]
     scope_success<std::decay_t<EF>> make_scope_success(EF&& exitFunction)
     {
-        return scope_success<std::decay_t<EF>>{std::forward<EF>(exitFunction)};
+        return scope_success{std::forward<EF>(exitFunction)};
     }
 
 }

include/unique_resource.h

                                                             noexcept(std::is_nothrow_constructible_v<std::decay_t<R>, R>
                                                                     && std::is_nothrow_constructible_v<std::decay_t<D>, D>)
     {
-        return unique_resource<std::decay_t<R>, std::decay_t<D>>{std::forward<R>(r), std::forward<D>(d)};
+        return unique_resource{std::forward<R>(r), std::forward<D>(d)};
     }
 
     template<class R, class D>
     unique_resource<R&, std::decay_t<D>> make_unique_resource(std::reference_wrapper<R> r, D d)
                                                 noexcept(std::is_nothrow_constructible_v<std::decay_t<D>, D>)
     {
-        return unique_resource<R&, std::decay_t<D>>{r.get(), std::forward<D>(d)};
+        return unique_resource{r.get(), std::forward<D>(d)};
     }
 
     template<class R, class D, class S = R>