#include <string>
#include <functional>

template<typename U, typename F> class Bar;

template <typename T>
struct Foo {
    using value_type = T;
    template<typename U>
    Bar<U,Foo<T>> make_bar(std::function<U(const T&)> getter) {
        return Bar<U,Foo<T>>(*this,getter);
    }
};

template <typename U,typename F>
struct Bar {
    F & f;
    std::function<U(const F::value_type&)> getter;
    Bar(F & f_,std::function<U(const typename F::value_type &)> getter_):f(f_),getter(getter_) {
    }
};

int main() {
    Foo<std::string> foo;
    auto b = foo.make_bar<std::size_t>([](auto v) { return v.size();}); // <--- так работает
    //    auto b1 = foo.make_bar([](auto v) { return v.size();}); // <--- хочу вот так
    //   auto b2 = foo.make_bar([](auto v) ->std::size_t { return v.size();}); // <--- или хотя бы так
    return 0;
}

Есть ли способ избежать явной специализации при вызове make_bar?

Здравствуйте, Vinick, Вы писали:
Сам спросил, сам ответил

Оказывается можно сделать вот так

template <typename T>
struct Foo {
    using value_type = T;
    using this_type = Foo<T>;

    auto make_bar(auto getter) ->  Bar<decltype(getter(value_type())),this_type> {
     return Bar<decltype(getter(value_type())),Foo<T>>(*this,getter);
    }

};

Правда теперь требуется чтобы у T был конструктор по умолчанию, но это уже мелочи.

Здравствуйте, Vinick, Вы писали:

V>Правда теперь требуется чтобы у T был конструктор по умолчанию, но это уже мелочи.

Может быть тебе поможет declval?

Здравствуйте, mbait, Вы писали:

M>Здравствуйте, Vinick, Вы писали:

V>>Правда теперь требуется чтобы у T был конструктор по умолчанию, но это уже мелочи.

M>Может быть тебе поможет declval?

О! спасибо, теперь вобще со всеми типами работает.