Atualmente estou trabalhando em uma biblioteca onde estou encadeando objetos de função.

Eu estou criando um modelo de função que leva um objeto que pode ser chamado (std :: function no momento) e é parametrizado no tipo de saída e entrada da função. Aqui está uma versão simplificada do que estou definindo:

template <typename In, typename Out>
std::vector<Out> process(std::vector<In> vals, std::function< Out(In) > func)
{
    // apply func for each value in vals
    return result;
}

O problema que estou tendo está em uso. Parece que quando eu passar um lambda, o compilador não pode deduzir o tipo corretamente, então reclama que a função não existe:

std::vector<string> strings;
// does NOT compile
auto chars = process(strings,
        []( std::string s ) -> char
        {
            return s[0]; // return first char
        }
);

Se eu envolver explicitamente o lambda emstd::function, o programa compila:

std::vector<string> strings;
// DOES compile
auto chars = process(strings,
        std::function< char(std::string) >(
        []( std::string s ) -> char
        {
            return s[0]; // return first char
        })
);

Eu não testei a passagem de ponteiros de função ou objetos de função ainda, mas parece que será difícil para o compilador deduzir oIn eOut parâmetros se eu não estou passando diretamente o explícitostd::function objeto.

Minha pergunta é a seguinte: existe uma maneira de contornar isso, para que eu possa deduzir o tipo de entrada / retorno de um objeto que pode ser chamado sem mencioná-los explicitamente no site da chamada?

Talvez parametrize o modelo no tipo de função em vez dos tipos de entrada / retorno? Essencialmente eu preciso deduzir oIn eOut digite para um callable arbitrário. Talvez algum tipo deauto/decltype truque para o tipo de retorno da função de modelo?

Obrigado.