Как получить связыватели функций в одном классе?

Question

Я пытаюсь понять, как работают связыватели функций. До сих пор у меня есть небольшая папка для 0-2 аргументов, которая прекрасно работает, но я не знаю, как поместить ее в один класс (например, функцию<>), чтобы сохранить ее в коллекции.

template <int>
struct placeholder {};

static const placeholder<1> _1_;
static const placeholder<2> _2_;

template <typename t>
struct list1
{
    list1(const t& i) : itm(i) {}
    t operator[](const placeholder<1>&) const {return itm;}
    template <typename it>
    it operator[](const it& _it) const {return _it;}

    template <typename fn>
    void operator()(fn func)
    {
        func(itm);
    }
    template <typename func, typename lst>
    void operator()(func fn, const lst& _lst)
    {
        fn(_lst[itm]);
    }
private:
    t itm;
};

template <typename t, typename t1>
struct list2
{
    list2(const t& i, const t1& i1) : itm(i), itm1(i1) {}
    t operator[](const placeholder<1>&) const {return itm;}
    t1 operator[](const placeholder<2>&) const {return itm1;}
    template <typename it>
    it operator[](const it& _it) const {return _it;}

    template <typename fn>
    void operator()(fn func)
    {
        func(itm, itm1);
    }
    template <typename func, typename lst>
    void operator()(func fn, const lst& _lst)
    {
        fn(_lst[itm], _lst[itm1]);
    }
private:
    t itm;
    t1 itm1;
};

template <typename func, typename lst>
class binder
{
public:
    binder(func _fn, const lst& _lst) : fn(_fn), _list(_lst) {}
    void operator()()
    {
        _list(fn);
    }
    template <typename a0>
    void operator()(const a0& _a0)
    {
        list1<a0> lst(_a0);
        _list(fn, lst);
    }
    template <typename a0, typename a1>
    void operator()(const a0& _a0, const a1& _a1)
    {
        list2<a0, a1> lst(_a0, _a1);
        _list(fn, lst);
    }
private:
    func fn;
    lst _list;
};

Обычно я использовал бы стирание типа, но я просто не могу понять это. Мне нужно было бы унаследовать от базового класса и сделать оператор ()(...)- шаблон виртуальным, что невозможно. Кто-нибудь знает, как они решили это в стандартной библиотеке?