Tipo de retorno explícito de lambda

Quando tento compilar este código (VS2010), recebo o seguinte erro: error C3499: a lambda that has been specified to have a void return type cannot return a value

void DataFile::removeComments()
{
  string::const_iterator start, end;
  boost::regex expression("^\\s?#");
  boost::match_results<std::string::const_iterator> what;
  boost::match_flag_type flags = boost::match_default;
  // Look for lines that either start with a hash (#)
  // or have nothing but white-space preceeding the hash symbol
  remove_if(rawLines.begin(), rawLines.end(), [&expression, &start, &end, &what, &flags](const string& line)
  {
    start = line.begin();
    end = line.end();
    bool temp = boost::regex_search(start, end, what, expression, flags);
    return temp;
  });
}

Como especifiquei que o lambda tem um tipo de retorno 'void'. Além disso, como posso especificar que o lambda tem o tipo de retorno 'bool'?

ATUALIZAR

O seguinte compila. Alguém pode me dizer por que isso compila e o outro não?

void DataFile::removeComments()
{
  boost::regex expression("^(\\s+)?#");
  boost::match_results<std::string::const_iterator> what;
  boost::match_flag_type flags = boost::match_default;
  // Look for lines that either start with a hash (#)
  // or have nothing but white-space preceeding the hash symbol
  rawLines.erase(remove_if(rawLines.begin(), rawLines.end(), [&expression, &what, &flags](const string& line)
  { return boost::regex_search(line.begin(), line.end(), what, expression, flags); }));
}

Você pode especificar explicitamente o tipo de retorno de um lambda usando -> Typeapós a lista de argumentos:

[]() -> Type { }

No entanto, se um lambda tem uma instrução e essa instrução é uma instrução de retorno (e retorna uma expressão), o compilador pode deduzir o tipo de retorno do tipo daquela expressão retornada. Você tem várias instruções em seu lambda, então ele não deduz o tipo.

O tipo de retorno de um lambda (em C ++ 11) pode ser deduzido, mas apenas quando há exatamente uma instrução, e essa instrução é uma returninstrução que retorna uma expressão (uma lista de inicializadores não é uma expressão, por exemplo). Se você tiver um lambda com várias instruções, o tipo de retorno será considerado nulo.

Portanto, você deve fazer isso:

  remove_if(rawLines.begin(), rawLines.end(), [&expression, &start, &end, &what, &flags](const string& line) -> bool
  {
    start = line.begin();
    end = line.end();
    bool temp = boost::regex_search(start, end, what, expression, flags);
    return temp;
  })

Mas, realmente, sua segunda expressão é muito mais legível.

Você pode ter mais de um extrato quando ainda retornar:

[]() -> your_type {return (
        your_statement,
        even_more_statement = just_add_comma,
        return_value);}

http://www.cplusplus.com/doc/tutorial/operators/#comma