Tipo de retorno explícito de Lambda

Cuando intento compilar este código (VS2010), aparece el siguiente error: 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;
  });
}

¿Cómo especifiqué que el lambda tiene un tipo de retorno 'vacío'? Además, ¿cómo especifico que la lambda tiene el tipo de retorno 'bool'?

ACTUALIZAR

Lo siguiente compila. ¿Alguien puede decirme por qué se compila y el otro no?

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); }));
}

Puede especificar explícitamente el tipo de retorno de una lambda utilizando -> Type después de la lista de argumentos:

[]() -> Type { }

Sin embargo, si una lambda tiene una declaración y esa declaración es una declaración de retorno (y devuelve una expresión), el compilador puede deducir el tipo de retorno del tipo de esa expresión devuelta. Tiene varias declaraciones en su lambda, por lo que no deduce el tipo.

El tipo de retorno de una lambda (en C ++ 11) se puede deducir, pero solo cuando hay exactamente una declaración, y esa declaración es una returndeclaración que devuelve una expresión (una lista de inicializadores no es una expresión, por ejemplo). Si tiene una lambda de declaración múltiple, se supone que el tipo de retorno es nulo.

Por lo tanto, debes hacer esto:

  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;
  })

Pero en realidad, tu segunda expresión es mucho más legible.

Puede tener más de una declaración cuando aún regrese:

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

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