algumas ideias para deixar sua linguagem mais robusta e intuitiva A verbosida... · paulohensil

Em resposta a [PITCH] Estou criando uma linguagem de programação

algumas ideias para deixar sua linguagem mais robusta e intuitiva
A verbosidade de C++ muitas vezes vem da necessidade de especificar tipos repetidamente, gerenciar memória manualmente e usar operadores complexos para tarefas comuns.A nova linguagem abordaria isso das seguintes maneiras:
Inferência de Tipo Automática: A linguagem seria capaz de inferir o tipo da maioria das variáveis no momento da declaração. Isso eliminaria a necessidade de declarar explicitamente o tipo, como auto em C++ moderno, mas tornaria isso a norma, não a exceção.

Exemplo: “let” ou “var” x = 10; (o compilador sabe que x é um inteiro).

Para tipos mais complexos, como classes, a inferência também funcionaria, como let minha_instancia = MinhaClasse();.

Gerenciamento de Memória Automático: Em vez de exigir o uso de new, delete e ponteiros inteligentes (como std::unique_ptr), a linguagem teria um sistema de gerenciamento de memória integrado. Isso poderia ser um garbage collector (coletor de lixo) ou um sistema de contagem de referências que liberasse a memória automaticamente quando ela não fosse mais necessária. Isso eliminaria a causa da maioria dos vazamentos de memória e erros de segmentação.

Ponteiros Simplificados: Os ponteiros seriam mais como "referências seguras". Eles seriam usados para passar objetos por referência sem a sintaxe de * e &.

A linguagem teria um conceito de ponteiro nulo claro e seguro, que impediria operações em ponteiros inválidos em tempo de compilação, em vez de em tempo de execução.

Visualize ponteiros como “setas”
Uma dica mental: pense sempre que

" * >>> pega o valor no destino da seta"
" & >>> pega o endereço para onde a seta deve apontar"
Sintaxe de Classes Simplificada: A declaração de classes e métodos seria mais limpa, com menos repetição de palavras-chave. A herança seria clara e a sobrescrita de métodos seria explícita, mas sem a necessidade de virtual e override na maioria dos casos. O uso de construtores e destrutores seria simplificado, com um foco maior em inicialização e finalização automáticas.

Encapsulamento por Padrão: Os membros de uma classe seriam privados por padrão, exigindo a palavra-chave public para expor o que deve ser acessível. Isso incentivaria a boa prática de encapsulamento desde início.
Melhoria do goto
O goto é malvisto por tornar o fluxo de controle de um programa imprevisível e difícil de seguir, criando o chamado "código espaguete". Em vez de eliminá-lo completamente, a melhoria seria limitar seu uso a contextos específicos e controlados, oferecendo alternativas mais seguras e legíveis.
A nova linguagem não teria um goto tradicional. Em vez disso, ela teria um recurso chamado jump com escopo.
jump para Labels de Bloco: O jump só poderia ser usado para "pular" para um rótulo (label) definido dentro do mesmo bloco de código (uma função ou um loop). Isso impediria que o fluxo de controle saísse de uma função para outra, garantindo que o jump não criasse dependências invisíveis entre diferentes partes do código.

Sintaxe Clara: A sintaxe seria jump <label_name>;. Isso tornaria a intenção clara. Os rótulos seriam definidos com uma sintaxe simples, como label <label_name>: para que fossem facilmente identificáveis.

Casos de Uso Específicos: O uso do jump seria incentivado apenas para situações de tratamento de erro ou para sair de múltiplos loops aninhados. A linguagem teria estruturas como break e continue para a maioria dos casos de uso, mas o jump seria uma ferramenta de último recurso, para quando outras opções de fluxo de controle fossem muito complexas ou ineficientes.

lucasdaniel

3 meses atrás

que ótima ideia! realmente C++ é bem verboso e considero isso problemático, e no lugar de um tipo "auto" como no C++, ao declarar uma variável, o compilador detecta automaticamente o tipo, como em C#:

var x = 1
var user = User(name, email, password)

Sobre o gerenciamento de memória, não penso em colocar um GC, por ser uma linguagem de baixo nível. E ainda prefiro os smart pointers, mas na linguagem, eles seriam simples, claros e diretos. Mas as referências serão uma opção alternativa, com os ponteiros sendo mais para memória heap.

Quanto a orientação a objetos, a sintaxe será mais simples, algo como:

class User {
    public property string name { get; set; }
    
    public int age; // Field ou campo, funciona como uma variável
    
    public string toString();
    
    private void privateMethod();
}

os métodos pra get/set poderão ser auto-implementados, definidos diretamente (anônimos) ou passados externamente, por exemplo:

property name { get { return _name; } set { _name = value }}

property name {get getName; set setName;} // Um ponteiro para um método/função (útil pra factory)

E todos os membros de uma classe serão privados por padrão.

goto e jump são uma ideia interessante, mas o projeto ainda está no início