Isso faz parte de uma série de perguntas que se concentra em um projeto chamado Abstraction Project, que visa abstrair os conceitos usados no design de linguagem na forma de uma estrutura.
Outra página associada a ela relacionada à tipagem estrutural pode ser vista aqui . O meta-tópico associado a uma consulta sobre a estrutura e o local apropriado para publicação pode ser encontrado aqui .
Quão fácil deve ser usar um Framework de Desenvolvimento de Linguagem?
Escrevi estruturas de geração de código em larga escala que também incluíam a capacidade de enviar o resultado ao compilador específico do idioma. O tópico da facilidade de uso surge de um exemplo de estrutura: CodeDOM, ou o Code Document Object Model.
É uma estrutura escrita pela Microsoft que descreve estruturas de código comuns, mas geralmente deixa muito de fora (coerção de expressão) e tende a ser um pouco abstrata na representação de certas construções, emitindo códigos ruins com base no que você estava fazendo: anteriormente CodeDOM mal tratada emitindo PrivateImplementationTypeem CodeMemberMethod, quando o tipo utilizado foi uma interface genérica. O CodeDOM foi minha razão original para escrever meu primeiro gerador de código.
Uma coisa que estou tentando fazer, para simplificar a estrutura, é reduzir a quantidade de trabalho que você precisa para fazer alguma coisa e se concentrar nas ações versus os tipos específicos que compõem essas ações.
Aqui está uma comparação lado a lado de como a estrutura que estou escrevendo funciona:
//Truncated...
/* *
* From a project that generates a lexer, this is the
* state->state transition character range selection logic.
* */
var nextChar = nextMethod.Parameters.Add(new TypedName("currentChar", typeof(char).GetTypeReference()));
//...
char start = rangeElement.B.Value.Start;
char end = rangeElement.B.Value.End;
/* *
* 'start' <= nextChar && nextChar <= 'end'
* */
currentExpression = start.LessThanOrEqualTo(nextChar).LogicalAnd(nextChar.LessThanOrEqualTo(end));
Versus CodeDOM:
//Truncated...
var nextChar = new CodeVariableReferenceExpression("nextChar");
//...
var start = new CodePrimitiveExpression(rangeElement.B.Value.Start);
var end = new CodePrimitiveExpression(rangeElement.B.Value.End);
currentExpression = new CodeBinaryOperatorExpression(new CodeBinaryOperatorExpression(start, CodeBinaryOperatorType.LessThanOrEqual, nextChar), CodeBinaryOperatorType.BooleanAnd, new CodeBinaryOperatorExpression(nextChar, CodeBinaryOperatorType.LessThanOrEqual, end));
O foco da estrutura são os entusiastas da linguagem, bem como aqueles interessados em gerar código ou aplicativos. Dado seu foco na compilação, geração de código e desenvolvimento de linguagem, a estrutura deve se concentrar na facilidade de uso ou no poder bruto?
Meu principal objetivo é aumentar a disponibilidade dessas ferramentas, para que os interessados no domínio não exijam muita experiência no domínio da teoria da linguagem antes de começarem a trabalhar em seus próprios projetos centrados na linguagem.
Dado que sou o autor do framework, minha visão de "usabilidade" é tendenciosa. Portanto, devo perguntar a outro se o foco e a meta fazem sentido para outras pessoas que não estão associadas ao projeto.