From 462e6f0659a0e96904088e2641d9fc9c1daca635 Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Sun, 11 Sep 2016 17:58:16 +0200
Subject: [PATCH] new ostd::Function implementation (cleaner with better
 allocator awareness including stateful allocators)

---
 ostd/functional.hh | 752 +++++++++++++++++++++++----------------------
 ostd/memory.hh     |   4 +-
 2 files changed, 393 insertions(+), 363 deletions(-)

diff --git a/ostd/functional.hh b/ostd/functional.hh
index 4594267..aa731e2 100644
--- a/ostd/functional.hh
+++ b/ostd/functional.hh
@@ -1,6 +1,7 @@
 /* Function objects for OctaSTD.
  *
  * This file is part of OctaSTD. See COPYING.md for futher information.
+ * Portions of this file are originally adapted from the libc++ project.
  */
 
 #ifndef OSTD_FUNCTIONAL_HH
@@ -13,6 +14,7 @@
 #include "ostd/memory.hh"
 #include "ostd/utility.hh"
 #include "ostd/type_traits.hh"
+#include <ostd/tuple.hh>
 
 namespace ostd {
 
@@ -542,409 +544,435 @@ detail::MemFn<R, T> mem_fn(R T:: *ptr) {
     return detail::MemFn<R, T>(ptr);
 }
 
-/* function impl
- * reference: http://probablydance.com/2013/01/13/a-faster-implementation-of-stdfunction
+/* function impl adapted from libc++
  */
 
 template<typename>
-struct Function;
+class Function;
 
 namespace detail {
-    struct FunctorData {
-        void *p1, *p2;
+    template<typename T>
+    inline bool func_is_not_null(T const &) {
+        return true;
+    }
+
+    template<typename T>
+    inline bool func_is_not_null(T *ptr) {
+        return ptr;
+    }
+
+    template<typename R, typename C>
+    inline bool func_is_not_null(R C::*ptr) {
+        return ptr;
+    }
+
+    template<typename T>
+    inline bool func_is_not_null(Function<T> const &f) {
+        return !!f;
+    }
+
+    template<typename F, typename ...A>
+    inline auto func_invoke_helper(F &&f, A &&...args) {
+        return forward<F>(f)(forward<A>(args)...);
+    }
+
+    template<typename R>
+    struct FuncInvokeVoidReturnWrapper {
+        template<typename ...A>
+        static R call(A &&...args) {
+            return func_invoke_helper(forward<A>(args)...);
+        }
+    };
+
+    template<>
+    struct FuncInvokeVoidReturnWrapper<void> {
+        template<typename ...A>
+        static void call(A &&...args) {
+            func_invoke_helper(forward<A>(args)...);
+        }
     };
 
     template<typename T>
-    constexpr bool FunctorInPlace =
-        sizeof(T) <= sizeof(FunctorData) &&
-        (alignof(FunctorData) % alignof(T)) == 0 && IsMoveConstructible<T>;
-
-    struct FunctionManager;
-
-    struct FmStorage {
-        FunctorData data;
-        FunctionManager const *manager;
-
-        template<typename A>
-        A &get_alloc() {
-            union {
-                FunctionManager const **m;
-                A *alloc;
-            } u;
-            u.m = &manager;
-            return *u.alloc;
-        }
-        template<typename A>
-        A const &get_alloc() const {
-            union {
-                FunctionManager const * const *m;
-                A const *alloc;
-            } u;
-            u.m = &manager;
-            return *u.alloc;
-        }
-    };
-
-    template<typename T, typename A, typename E = void>
-    struct FunctorDataManager {
-        template<typename R, typename ...Args>
-        static R call(FunctorData const &s, Args ...args) {
-            return (*reinterpret_cast<T *>(&const_cast<FunctorData &>(s)))(
-                forward<Args>(args)...
-            );
-        }
-
-        static void store_f(FmStorage &s, T v) {
-            new (&get_ref(s)) T(forward<T>(v));
-        }
-
-        static void move_f(FmStorage &lhs, FmStorage &&rhs) {
-            new (&get_ref(lhs)) T(move(get_ref(rhs)));
-        }
-
-        static void destroy_f(A &, FmStorage &s) {
-            get_ref(s).~T();
-        }
-
-        static T &get_ref(FmStorage const &s) {
-            union {
-                FunctorData const *data;
-                T *ret;
-            } u;
-            u.data = &s.data;
-            return *u.ret;
-        }
-    };
-
-    template<typename T, typename A>
-    struct FunctorDataManager<T, A, EnableIf<!FunctorInPlace<T>>> {
-        template<typename R, typename ...Args>
-        static R call(FunctorData const &s, Args ...args) {
-            return (*reinterpret_cast<AllocatorPointer<A> &>(
-                const_cast<FunctorData &>(s))
-            )(forward<Args>(args)...);
-        }
-
-        static void store_f(FmStorage &s, T v) {
-            A &a = s.get_alloc<A>();
-            AllocatorPointer<A> *ptr = new (&get_ptr_ref(s))
-                AllocatorPointer<A>(allocator_allocate(a, 1));
-            allocator_construct(a, *ptr, forward<T>(v));
-        }
-
-        static void move_f(FmStorage &lhs, FmStorage &&rhs) {
-            new (&get_ptr_ref(lhs)) AllocatorPointer<A>(move(get_ptr_ref(rhs)));
-            get_ptr_ref(rhs) = nullptr;
-        }
-
-        static void destroy_f(A &a, FmStorage &s) {
-            AllocatorPointer<A> &ptr = get_ptr_ref(s);
-            if (!ptr) {
-                return;
-            }
-            allocator_destroy(a, ptr);
-            allocator_deallocate(a, ptr, 1);
-            ptr = nullptr;
-        }
-
-        static T &get_ref(FmStorage const &s) {
-            return *get_ptr_ref(s);
-        }
-
-        static AllocatorPointer<A> &get_ptr_ref(FmStorage &s) {
-            return reinterpret_cast<AllocatorPointer<A> &>(s.data);
-        }
-
-        static AllocatorPointer<A> &get_ptr_ref(FmStorage const &s) {
-            return reinterpret_cast<AllocatorPointer<A> &>(
-                const_cast<FunctorData &>(s.data)
-            );
-        }
-    };
-
-    template<typename T, typename A>
-    static FunctionManager const &get_default_fm();
-
-    template<typename T, typename A>
-    static void create_fm(FmStorage &s, A &&a) {
-        new (&s.get_alloc<A>()) A(move(a));
-        s.manager = &get_default_fm<T, A>();
-    }
-
-    struct FunctionManager {
-        template<typename T, typename A>
-        inline static constexpr FunctionManager create_default_manager() {
-            return FunctionManager {
-                &call_move_and_destroy<T, A>,
-                &call_copy<T, A>,
-                &call_copy_fo<T, A>,
-                &call_destroy<T, A>
-            };
-        }
-
-        void (* const call_move_and_destroyf)(
-            FmStorage &lhs, FmStorage &&rhs
-        );
-        void (* const call_copyf)(
-            FmStorage &lhs, FmStorage const &rhs
-        );
-        void (* const call_copyf_fo)(
-            FmStorage &lhs, FmStorage const &rhs
-        );
-        void (* const call_destroyf)(FmStorage &s);
-
-        template<typename T, typename A>
-        static void call_move_and_destroy(FmStorage &lhs, FmStorage &&rhs) {
-            using Spec = FunctorDataManager<T, A>;
-            Spec::move_f(lhs, move(rhs));
-            Spec::destroy_f(rhs.get_alloc<A>(), rhs);
-            create_fm<T, A>(lhs, move(rhs.get_alloc<A>()));
-            rhs.get_alloc<A>().~A();
-        }
-
-        template<typename T, typename A>
-        static void call_copy(FmStorage &lhs, FmStorage const &rhs) {
-            using Spec = FunctorDataManager<T, A>;
-            create_fm<T, A>(lhs, A(rhs.get_alloc<A>()));
-            Spec::store_f(lhs, Spec::get_ref(rhs));
-        }
-
-        template<typename T, typename A>
-        static void call_copy_fo(FmStorage &lhs, FmStorage const &rhs) {
-            using Spec = FunctorDataManager<T, A>;
-            Spec::store_f(lhs, Spec::get_ref(rhs));
-        }
-
-        template<typename T, typename A>
-        static void call_destroy(FmStorage &s) {
-            using Spec = FunctorDataManager<T, A>;
-            Spec::destroy_f(s.get_alloc<A>(), s);
-            s.get_alloc<A>().~A();
-        }
-    };
-
-    template<typename T, typename A>
-    inline static FunctionManager const &get_default_fm() {
-        static FunctionManager const def_manager =
-            FunctionManager::create_default_manager<T, A>();
-        return def_manager;
-    }
-
-    template<typename R, typename...>
-    struct FunctionBase {
-        using Result = R;
-    };
-
-    template<typename R, typename T>
-    struct FunctionBase<R, T> {
-        using Result = R;
-        using Argument = T;
-    };
-
-    template<typename R, typename T, typename U>
-    struct FunctionBase<R, T, U> {
-        using Result = R;
-        using FirstArgument = T;
-        using SecondArgument = U;
-    };
-
-    template<typename, typename>
-    constexpr bool IsValidFunctor = false;
+    class FuncBase;
 
     template<typename R, typename ...A>
-    constexpr bool IsValidFunctor<Function<R(A...)>, R(A...)> = false;
+    class FuncBase<R(A...)> {
+        FuncBase(FuncBase const &);
+        FuncBase &operator=(FuncBase const &);
+    public:
+        FuncBase() {}
+        virtual ~FuncBase() {}
+        virtual FuncBase *clone() const = 0;
+        virtual void clone(FuncBase *) const = 0;
+        virtual void destroy() noexcept = 0;
+        virtual void destroy_deallocate() noexcept = 0;
+        virtual R operator()(A &&...args) = 0;
+    };
 
-    template<typename T>
-    T func_to_functor(T &&f) {
-        return forward<T>(f);
+    template<typename F, typename A, typename AT>
+    class FuncCore;
+
+    template<typename F, typename A, typename R, typename ...AT>
+    class FuncCore<F, A, R(AT...)>: public FuncBase<R(AT...)> {
+        CompressedPair<F, A> f_stor;
+public:
+        explicit FuncCore(F &&f):
+            f_stor(
+                piecewise_construct,
+                forward_as_tuple(ostd::move(f)),
+                forward_as_tuple()
+            )
+        {}
+
+        explicit FuncCore(F const &f, A const &a):
+            f_stor(
+                piecewise_construct,
+                forward_as_tuple(f),
+                forward_as_tuple(a)
+            )
+        {}
+
+        explicit FuncCore(F const &f, A &&a):
+            f_stor(
+                piecewise_construct,
+                forward_as_tuple(f),
+                forward_as_tuple(ostd::move(a))
+            )
+        {}
+
+        explicit FuncCore(F &&f, A &&a):
+            f_stor(
+                piecewise_construct,
+                forward_as_tuple(ostd::move(f)),
+                forward_as_tuple(ostd::move(a))
+            )
+        {}
+
+        virtual FuncBase<R(AT...)> *clone() const;
+        virtual void clone(FuncBase<R(AT...)> *) const;
+        virtual void destroy() noexcept;
+        virtual void destroy_deallocate() noexcept;
+        virtual R operator()(AT &&...args);
+    };
+
+    template<typename F, typename A, typename R, typename ...AT>
+    FuncBase<R(AT...)> *FuncCore<F, A, R(AT...)>::clone() const {
+        using AA = AllocatorRebind<A, FuncCore>;
+        AA a(f_stor.second());
+        using D = AllocatorDestructor<AA>;
+        Box<FuncCore, D> hold(a.allocate(1), D(a, 1));
+        ::new(hold.get()) FuncCore(f_stor.first(), A(a));
+        return hold.release();
     }
 
-    template<typename RR, typename T, typename ...AA>
-    auto func_to_functor(RR (T::*f)(AA...))
-        -> decltype(mem_fn(f)) {
-        return mem_fn(f);
+    template<typename F, typename A, typename R, typename ...AT>
+    void FuncCore<F, A, R(AT...)>::clone(FuncBase<R(AT...)> *p) const {
+        ::new (p) FuncCore(f_stor.first(), f_stor.second());
     }
 
-    template<typename RR, typename T, typename ...AA>
-    auto func_to_functor(RR (T::*f)(AA...) const)
-        -> decltype(mem_fn(f)) {
-        return mem_fn(f);
+    template<typename F, typename A, typename R, typename ...AT>
+    void FuncCore<F, A, R(AT...)>::destroy() noexcept {
+        f_stor.~CompressedPair<F, A>();
     }
 
-    struct ValidFunctorNat {};
+    template<typename F, typename A, typename R, typename ...AT>
+    void FuncCore<F, A, R(AT...)>::destroy_deallocate() noexcept {
+        using AA = AllocatorRebind<A, FuncCore>;
+        AA a(f_stor.second());
+        f_stor.~CompressedPair<F, A>();
+        a.deallocate(this, 1);
+    }
 
-    template<typename U, typename ...A>
-    static decltype(
-        func_to_functor(declval<U>()) (declval<A>()...)
-    ) valid_functor_test(U *);
-    template<typename, typename ...>
-    static ValidFunctorNat valid_functor_test(...);
-
-    template<typename T, typename R, typename ...A>
-    constexpr bool IsValidFunctor<T, R(A...)> =
-        IsConvertible<decltype(valid_functor_test<T, A...>(nullptr)), R>;
-
-    template<typename T>
-    using FunctorType = decltype(func_to_functor(declval<T>()));
+    template<typename F, typename A, typename R, typename ...AT>
+    R FuncCore<F, A, R(AT...)>::operator()(AT &&...args) {
+        using Invoker = FuncInvokeVoidReturnWrapper<R>;
+        return Invoker::call(f_stor.first(), forward<AT>(args)...);
+    }
 } /* namespace detail */
 
 template<typename R, typename ...Args>
-struct Function<R(Args...)>: detail::FunctionBase<R, Args...> {
-    Function(       ) { init_empty(); }
-    Function(Nullptr) { init_empty(); }
+class Function<R(Args...)> {
+    using Base = detail::FuncBase<R(Args...)>;
+    AlignedStorage<3 * sizeof(void *)> p_buf;
+    Base *p_f;
 
-    Function(Function &&f) {
-        init_empty();
-        swap(f);
+    static inline Base *as_base(void *p) {
+        return reinterpret_cast<Base *>(p);
     }
 
-    Function(Function const &f): p_call(f.p_call) {
-        f.p_stor.manager->call_copyf(p_stor, f.p_stor);
-    }
+    template<
+        typename F,
+        bool = !IsSame<F, Function> && detail::IsInvokable<F &, Args...>
+    >
+    struct CallableBase;
 
-    template<typename T, typename = EnableIf<
-        detail::IsValidFunctor<T, R(Args...)>
-    >>
-    Function(T f) {
-        if (func_is_null(f)) {
-            init_empty();
-            return;
-        }
-        initialize(detail::func_to_functor(
-            forward<T>(f)), Allocator<detail::FunctorType<T>>()
-        );
-    }
-
-    template<typename A>
-    Function(AllocatorArg, A const &) { init_empty(); }
-
-    template<typename A>
-    Function(AllocatorArg, A const &, Nullptr) { init_empty(); }
-
-    template<typename A>
-    Function(AllocatorArg, A const &, Function &&f) {
-        init_empty();
-        swap(f);
-    }
-
-    template<typename A>
-    Function(AllocatorArg, A const &a, Function const &f):
-        p_call(f.p_call)
-    {
-        detail::FunctionManager const *mfa =
-            &detail::get_default_fm<AllocatorValue<A>, A>();
-        if (f.p_stor.manager == mfa) {
-            detail::create_fm<AllocatorValue<A>, A>(p_stor, A(a));
-            mfa->call_copyf_fo(p_stor, f.p_stor);
-            return;
-        }
-
-        using AA = AllocatorRebind<A, Function>;
-        detail::FunctionManager const *mff =
-            &detail::get_default_fm<Function, AA>();
-        if (f.p_stor.manager == mff) {
-            detail::create_fm<Function, AA>(p_stor, AA(a));
-            mff->call_copyf_fo(p_stor, f.P_stor);
-            return;
-        }
-
-        initialize(f, AA(a));
-    }
-
-    template<typename A, typename T, typename = EnableIf<
-        detail::IsValidFunctor<T, R(Args...)>
-    >>
-    Function(AllocatorArg, A const &a, T f) {
-        if (func_is_null(f)) {
-            init_empty();
-            return;
-        }
-        initialize(detail::func_to_functor(forward<T>(f)), A(a));
-    }
-
-    ~Function() {
-        p_stor.manager->call_destroyf(p_stor);
-    }
-
-    Function &operator=(Function &&f) {
-        p_stor.manager->call_destroyf(p_stor);
-        swap(f);
-        return *this;
-    }
-
-    Function &operator=(Function const &f) {
-        p_stor.manager->call_destroyf(p_stor);
-        swap(Function(f));
-        return *this;
+    template<typename F>
+    struct CallableBase<F, true> {
+        static constexpr bool value =
+            IsSame<R, void> || IsConvertible<detail::InvokeOf<F &, Args...>, R>;
+    };
+    template<typename F>
+    struct CallableBase<F, false> {
+        static constexpr bool value = false;
     };
 
-    R operator()(Args ...args) const {
-        return p_call(p_stor.data, forward<Args>(args)...);
+    template<typename F>
+    static constexpr bool Callable = CallableBase<F>::value;
+
+public:
+    using Result = R;
+
+    Function() noexcept: p_f(nullptr) {}
+    Function(Nullptr) noexcept: p_f(nullptr) {}
+
+    Function(Function const &);
+    Function(Function &&) noexcept;
+
+    template<
+        typename F, typename = EnableIf<Callable<F> && !IsSame<F, Function>>
+    >
+    Function(F);
+
+    template<typename A>
+    Function(AllocatorArg, A const &) noexcept: p_f(nullptr) {}
+    template<typename A>
+    Function(AllocatorArg, A const &, Nullptr) noexcept: p_f(nullptr) {}
+    template<typename A>
+    Function(AllocatorArg, A const &, Function const &);
+    template<typename A>
+    Function(AllocatorArg, A const &, Function &&);
+    template<typename F, typename A, typename = EnableIf<Callable<F>>>
+    Function(AllocatorArg, A const &, F);
+
+    Function &operator=(Function const &f) {
+        Function(f).swap(*this);
+        return *this;
     }
 
-    template<typename F, typename A>
-    void assign(F &&f, A const &a) {
-        Function(allocator_arg, a, forward<F>(f)).swap(*this);
+    Function &operator=(Function &&) noexcept;
+    Function &operator=(Nullptr) noexcept;
+
+    template<typename F>
+    EnableIf<
+        Callable<Decay<F>> && !IsSame<RemoveReference<F>, Function>,
+        Function &
+    > operator=(F &&f) {
+        Function(forward<F>(f)).swap(*this);
+        return *this;
     }
 
-    void swap(Function &f) {
-        detail::FmStorage tmp;
-        f.p_stor.manager->call_move_and_destroyf(tmp, move(f.p_stor));
-        p_stor.manager->call_move_and_destroyf(f.p_stor, move(p_stor));
-        tmp.manager->call_move_and_destroyf(p_stor, move(tmp));
-        ostd::swap(p_call, f.p_call);
-    }
+    ~Function();
 
-    explicit operator bool() const { return p_call != nullptr; }
+    void swap(Function &) noexcept;
 
-private:
-    detail::FmStorage p_stor;
-    R (*p_call)(detail::FunctorData const &, Args...);
+    explicit operator bool() const noexcept { return p_f; }
 
-    template<typename T, typename A>
-    void initialize(T &&f, A &&a) {
-        p_call = &detail::FunctorDataManager<T, A>::template call<R, Args...>;
-        detail::create_fm<T, A>(p_stor, forward<A>(a));
-        detail::FunctorDataManager<T, A>::store_f(p_stor, forward<T>(f));
-    }
+    /* deleted overloads close possible hole in the type system */
+    template<typename RR, typename ...AA>
+    bool operator==(Function<RR(AA...)> &) const = delete;
+    template<typename RR, typename ...AA>
+    bool operator!=(Function<RR(AA...)> &) const = delete;
 
-    void init_empty() {
-        using emptyf = R(*)(Args...);
-        using emptya = Allocator<emptyf>;
-        p_call = nullptr;
-        detail::create_fm<emptyf, emptya>(p_stor, emptya());
-        detail::FunctorDataManager<emptyf, emptya>::store_f(p_stor, nullptr);
-    }
-
-    template<typename T>
-    static bool func_is_null(T const &) { return false; }
-
-    static bool func_is_null(R (* const &fptr)(Args...)) {
-        return fptr == nullptr;
-    }
-
-    template<typename RR, typename T, typename ...AArgs>
-    static bool func_is_null(RR (T::* const &fptr)(AArgs...)) {
-        return fptr == nullptr;
-    }
-
-    template<typename RR, typename T, typename ...AArgs>
-    static bool func_is_null(RR (T::* const &fptr)(AArgs...) const) {
-        return fptr == nullptr;
+    R operator()(Args ...a) const {
+        return (*p_f)(forward<Args>(a)...);
     }
 };
 
-template<typename T>
-bool operator==(Nullptr, Function<T> const &rhs) { return !rhs; }
+template<typename R, typename ...Args>
+Function<R(Args...)>::Function(Function const &f) {
+    if (!f.p_f) {
+        p_f = nullptr;
+    } else if (static_cast<void *>(f.p_f) == &f.p_buf) {
+        p_f = as_base(&p_buf);
+        f.p_f->clone(p_f);
+    } else {
+        p_f = f.p_f->clone();
+    }
+}
 
-template<typename T>
-bool operator==(Function<T> const &lhs, Nullptr) { return !lhs; }
+template<typename R, typename ...Args>
+template<typename A>
+Function<R(Args...)>::Function(
+    AllocatorArg, A const &, Function const &f
+) {
+    if (!f.p_f) {
+        p_f = nullptr;
+    } else if (static_cast<void *>(f.p_f) == &f.p_buf) {
+        p_f = as_base(&p_buf);
+        f.p_f->clone(p_f);
+    } else {
+        p_f = f.p_f->clone();
+    }
+}
 
-template<typename T>
-bool operator!=(Nullptr, Function<T> const &rhs) { return rhs; }
+template<typename R, typename ...Args>
+Function<R(Args...)>::Function(Function &&f) noexcept {
+    if (!f.p_f) {
+        p_f = nullptr;
+    } else if (static_cast<void *>(f.p_f) == &f.p_buf) {
+        p_f = as_base(&p_buf);
+        f.p_f->clone(p_f);
+    } else {
+        p_f = f.p_f;
+        f.p_f = nullptr;
+    }
+}
 
-template<typename T>
-bool operator!=(Function<T> const &lhs, Nullptr) { return lhs; }
+template<typename R, typename ...Args>
+template<typename A>
+Function<R(Args...)>::Function(
+    AllocatorArg, A const &, Function &&f
+) {
+    if (!f.p_f) {
+        p_f = nullptr;
+    } else if (static_cast<void *>(f.p_f) == &f.p_buf) {
+        p_f = as_base(&p_buf);
+        f.p_f->clone(p_f);
+    } else {
+        p_f = f.p_f;
+        f.p_f = nullptr;
+    }
+}
+
+template<typename R, typename ...Args>
+template<typename F, typename>
+Function<R(Args...)>::Function(F f): p_f(nullptr) {
+    if (!detail::func_is_not_null(f)) {
+        return;
+    }
+    using FF = detail::FuncCore<F, Allocator<F>, R(Args...)>;
+    if ((sizeof(FF) <= sizeof(p_buf)) && IsNothrowCopyConstructible<F>) {
+        p_f = ::new(static_cast<void *>(&p_buf)) FF(move(f));
+        return;
+    }
+    using AA = Allocator<FF>;
+    AA a;
+    using D = detail::AllocatorDestructor<AA>;
+    Box<FF, D> hold(a.allocate(1), D(a, 1));
+    ::new(hold.get()) FF(move(f), Allocator<F>(a));
+    p_f = hold.release();
+}
+
+template<typename R, typename ...Args>
+template<typename F, typename A, typename>
+Function<R(Args...)>::Function(AllocatorArg, A const &a, F f):
+    p_f(nullptr)
+{
+    if (!detail::func_is_not_null(f)) {
+        return;
+    }
+    using FF = detail::FuncCore<F, A, R(Args...)>;
+    using AA = AllocatorRebind<A, FF>;
+    AA aa(a);
+    if (
+        (sizeof(FF) <= sizeof(p_buf)) && IsNothrowCopyConstructible<F> &&
+        IsNothrowCopyConstructible<AA>
+    ) {
+        p_f = ::new(static_cast<void *>(&p_buf)) FF(move(f), A(aa));
+        return;
+    }
+    using D = detail::AllocatorDestructor<AA>;
+    Box<FF, D> hold(aa.allocate(1), D(aa, 1));
+    ::new(hold.get()) FF(move(f), A(aa));
+    p_f = hold.release();
+}
+
+template<typename R, typename ...Args>
+Function<R(Args...)> &Function<R(Args...)>::operator=(Function &&f)
+    noexcept
+{
+    if (static_cast<void *>(p_f) == &p_buf) {
+        p_f->destroy();
+    } else if (p_f) {
+        p_f->destroy_deallocate();
+    }
+    if (f.p_f == nullptr) {
+        p_f = nullptr;
+    } else if (static_cast<void *>(f.p_f) == &f.p_buf) {
+        p_f = as_base(&p_buf);
+        f.p_f->clone(p_f);
+    } else {
+        p_f = f.p_f;
+        f.p_f = nullptr;
+    }
+    return *this;
+}
+
+template<typename R, typename ...Args>
+Function<R(Args...)> &Function<R(Args...)>::operator=(Nullptr) noexcept {
+    if (static_cast<void *>(p_f) == &p_buf) {
+        p_f->destroy();
+    } else if (p_f) {
+        p_f->destroy_deallocate();
+    }
+    p_f = nullptr;
+    return *this;
+}
+
+template<typename R, typename ...Args>
+Function<R(Args...)>::~Function() {
+    if (static_cast<void *>(p_f) == &p_buf) {
+        p_f->destroy();
+    } else if (p_f) {
+        p_f->destroy_deallocate();
+    }
+}
+
+template<typename R, typename ...Args>
+void Function<R(Args...)>::swap(Function &f) noexcept {
+    if (
+        (static_cast<void *>(p_f) == &p_buf) &&
+        (static_cast<void *>(f.p_f) == &f.p_buf)
+    ) {
+        /* both in small storage */
+        AlignedStorage<sizeof(p_buf)> tmpbuf;
+        Base *t = as_base(&tmpbuf);
+        p_f->clone(t);
+        p_f->destroy();
+        p_f = nullptr;
+        f.p_f->clone(as_base(&p_buf));
+        f.p_f->destroy();
+        f.p_f = nullptr;
+        p_f = as_base(&p_buf);
+        t->clone(as_base(&f.p_buf));
+        t->destroy();
+        f.p_f = as_base(&f.p_buf);
+    } else if (static_cast<void *>(p_f) == &p_buf) {
+        /* ours in small storage */
+        p_f->clone(as_base(&f.p_buf));
+        p_f->destroy();
+        p_f = f.p_f;
+        f.p_f = as_base(&f.p_buf);
+    } else if (static_cast<void *>(f.p_f) == &f.p_buf) {
+        /* the other in small storage */
+        f.p_f->clone(as_base(&p_buf));
+        f.p_f->destroy();
+        f.p_f = p_f;
+        p_f = as_base(&p_buf);
+    } else {
+        detail::swap_adl(p_f, f.p_f);
+    }
+}
+
+template<typename R, typename ...Args>
+inline bool operator==(Function<R(Args...)> const &f, Nullptr) noexcept {
+    return !f;
+}
+
+template<typename R, typename ...Args>
+inline bool operator==(Nullptr, Function<R(Args...)> const &f) noexcept {
+    return !f;
+}
+
+template<typename R, typename ...Args>
+inline bool operator!=(Function<R(Args...)> const &f, Nullptr) noexcept {
+    return bool(f);
+}
+
+template<typename R, typename ...Args>
+inline bool operator!=(Nullptr, Function<R(Args...)> const &f) noexcept {
+    return bool(f);
+}
 
 namespace detail {
     template<typename F>
diff --git a/ostd/memory.hh b/ostd/memory.hh
index b8a59be..5f7aac4 100644
--- a/ostd/memory.hh
+++ b/ostd/memory.hh
@@ -1157,8 +1157,10 @@ namespace detail {
         A &p_alloc;
         Size p_size;
     public:
+        using Pointer = AllocatorPointer<A>;
+        using Size = ostd::Size;
         AllocatorDestructor(A &a, Size s) noexcept: p_alloc(a), p_size(s) {}
-        void operator()(AllocatorPointer<A> p) noexcept {
+        void operator()(Pointer p) noexcept {
             allocator_deallocate(p_alloc, p, p_size);
         }
     };