Por que o C ++ não pode adotar a abordagem de D para sua implementação de conceito?

Como muitos de vocês sabem, conceitos , a abordagem do C ++ para restringir tipos possíveis para um argumento de modelo não foi incluída no C ++ 11.

Aprendi que a linguagem de programação D 2.0 tem um recurso semelhante para sua programação genérica. Sua solução me parece bastante elegante e simples.

Portanto, minha pergunta é por que o C ++ não pode usar uma abordagem semelhante .

• O objetivo do conceito C ++ pode ser maior do que o que a implementação de D oferece?
• Ou o legado do C ++ impede que ele adote essa abordagem?
• Ou qualquer outro?

Obrigado por suas respostas.

ps Para ver alguns exemplos do poder de programação genérico de D, consulte: /programming/7300298/metaprogramming-in-c-and-in-d/7303534#7303534

O Padrão de C ++ é um documento normativo, que define regras que permanecerão (principalmente não afetadas) nos documentos futuros. Portanto, o comitê adotou uma abordagem muito cautelosa em relação a suas atualizações.

As adições à biblioteca padrão foram um pouco fáceis. Várias bibliotecas estiveram no Boost por um longo tempo: foi provado que elas funcionavam.

Adições aos conceitos principais da linguagem, no entanto, são muito mais difíceis de serem experimentadas, porque primeiro é necessário modificar um compilador. Um recurso C ++ 03 (a exportação de modelos) havia sido especificado sem o suporte do compilador ... o resultado foi horrível. Os implementadores do front-end do compilador EDG relataram isso como uma tarefa massiva (vários homens-ano) com muito pouco ganho. Nenhum outro compilador tentou implementá-lo. Não é uma situação confortável.

Recursos como constexprou static_asserteram fáceis (e já emulados pelas bibliotecas). As lambdas são bastante bem compreendidas e implementadas em uma variedade de outras línguas, já houve uma extensa pesquisa, portanto era principalmente uma questão de sintaxe.

Por outro lado, os conceitos foram julgados muito novos e não experimentados . Eles mal foram especificados a tempo, não havia prova de conceito ... e, portanto, foram rejeitados, em vez de esperar por eles (ou cometer um erro).

Por que não seguir D? Não há como dizer que não. O comitê incentivou as pessoas a repensar do zero, sem prazo determinado, e tentar incluí-las em um compilador para ver como elas interagem com outros recursos do idioma. É notável a questão de separar conceitos e mapas conceituais: eles devem ser agrupados como um ou não?

FYI: Atualmente, existe um ramo de Clang dedicado a essa experimentação, liderado por Larisse Voufo da universidade de Indiana.

Para o padrão de 2011, os conceitos de C ++ eram o que estava sendo trabalhado e, em última análise, foram retirados desse padrão, porque não foram "assados ​​o suficiente". O trabalho continua nos conceitos de C ++, que podem levá-los ao próximo padrão. Pode ser, no entanto, que algumas pessoas trabalhem em uma proposta para o próximo padrão, semelhante às restrições do modelo de D. Se isso acontece ou não, resta saber. Até onde eu sei, não havia essa proposta para o padrão de 2011, então não havia chance de ele entrar nesse padrão, independentemente de seus méritos, mas o que fará ou não o próximo padrão é completamente desconhecido. neste ponto.

Não estou ciente de nenhuma das principais razões pelas quais algo semelhante às restrições de modelo de D não pôde ser implementado para C ++, embora, como o C ++ seja geralmente mais limitado no que ele pode fazer em tempo de compilação, seja mais difícil fazê-los funcionar da mesma maneira. bem como em D (embora a introdução de coisas como constexprcertamente ajude).

Então, realmente, acho que a resposta curta é que não há nenhuma razão técnica para que algo semelhante às restrições de modelo de D não possa estar em C ++.

A questão é se tal proposta será feita para o próximo padrão e como será comparada com quaisquer propostas semelhantes feitas (por exemplo, propostas relacionadas a conceitos). Supondo que uma proposta aceitável possa ser feita, eu esperaria plenamente que algo semelhante aos conceitos ou restrições de modelo de D o tornasse o próximo padrão simplesmente porque há muito desejo por ela. A questão é se alguém pode apresentar uma proposta que seja sólida o suficiente e "assada o suficiente" para ser aceitável.

Você quer dizer que o modelo de D restringe?

Até onde eu sei, os conceitos de C ++ foram propostos em nome do boost :: concept. O problema, aqui, é que o boost é uma biblioteca escrita para C ++ 03. O C ++ 11 possui outros recursos de sintaxe que permitem implementar certas coisas de uma maneira diferente que o C ++ 03 permite (portanto, o próprio aumento pode ser reescrito, aproveitando a nova sintaxe).

O comitê padrão descartou conceitos porque demorou muito tempo para especificá-los (atrasando novamente a aprovação do c ++ 11). Eles provavelmente irão no próximo lançamento do C ++.

Enquanto isso, a sintaxe D é diferente, então o C ++ e o próprio D retêm alguns recursos de avaliação de expressão no tempo de compilação que o C ++ nem sempre pode ter sem quebrar algum código legado (algo que D não possui, tendo um histórico mais curto). O próprio C ++ agora tem static_asserte costexpr, isso permite melhorar os recursos de avaliação do tempo de compilação. Pode ser que no futuro atinja um nível semelhante.

Aqui está um controle de qualidade com Herb Sutter, ele fala sobre conceitos na marca dos 15 minutos.

http://channel9.msdn.com/Shows/Going+Deep/Herb-Sutter-C-Questions-and-Answers

Se você gosta disso, aqui está outro: http://channel9.msdn.com/Shows/Going+Deep/Conversation-with-Herb-Sutter-Perspectives-on-Modern-C0x11

Agora, quanto à sua pergunta. Por que não a versão D? Bem, por que usá-lo? C ++ é uma linguagem muito complexa e estável. Cada recurso precisa ser selecionado com muito cuidado, porque geralmente precisa ser suportado por décadas. Se você observar o primeiro padrão C ++ e seguir as revisões, existem alguns recursos preteridos, mas mesmo esses precisam ser suportados. Portanto, faz sentido projetar conceitos 100% adequados ao C ++.

Quanto ao motivo pelo qual não foi incluído no C ++ 0x. Bem, porque era enorme. A proposta tinha 100 páginas e era muito difícil de implementar. Foi decidido que esse recurso precisa de mais tempo para amadurecer até ser incluído no padrão.

Simplesmente, o C ++ tem muito mais bagagem histórica do que D. Seria muito mais fácil implementar muitas coisas, se não fosse pelo fato de o C ++ ter grandes quantidades de código histórico que devem continuar funcionando corretamente. e como esperado. D não tem esse problema.