A sintaxe de Clojure é realmente mais simples que a de Scala? [fechadas]

O argumento sempre feito em favor de Clojure é esse.

A sintaxe é mais simples e existe apenas uma maneira de expressar código sem regras complicadas.

No entanto, o Scala possui vários tipos diferentes de sintaxe e construções em comparação com o Clojure.

Mas, desde a última semana, enquanto tentava aprender Clojure, notei que a lista de macros embutidas é infinita. Mesmo que as escrevamos com a mesma sintaxe entre parênteses, precisamos aprender como cada uma funciona.

Então, em que sentido a sintaxe de Clojure é mais simples? Para os LISPers, pode ser, mas para pessoas de diferentes origens, aprendendo diferentes construções no Scala, parece mais simples.

Então, de um ponto de vista neutro, qual sintaxe é mais simples e legível?

Então, de um ponto de vista neutro, qual sintaxe é mais simples e legível?

Essas são duas perguntas muito diferentes.

Mais simples significa "composto por menos partes". A sintaxe de Clojure tem menos regras, portanto é objetivamente mais simples que a de Scala.

A legibilidade , no entanto, é subjetiva. Tudo se resume principalmente à familiaridade . Por exemplo, acho que ECMAScript, C #, Java, D, Go, C ++ e C são quase incompreensíveis, mas para quem está acostumado a ler esse tipo de sintaxe, é bastante legível. Esta parte da pergunta não pode ser respondida objetivamente ou "de um ponto de vista neutro".

Quando trabalho na Scala, geralmente há uma fase do meu desenvolvimento (especialmente com forcompreensão) em que tenho que fazer todos os tipos funcionarem corretamente, o que é uma grande vantagem para grandes projetos, mas um negativo definitivo para os pequenos. Eu esperava que pudesse esquecer tipos e me concentrar em "fazer o trabalho" no Clojure da maneira que me lembro vagamente de fazer no Perl ou no Awk, mas até agora não funcionou dessa maneira para mim. Minha experiência é que, em vez de "fazer os tipos funcionarem" na fase de código / compilação, estou recebendo exceções quando tento executar meu código. Isso não é uma simplificação; o problema não desapareceu, foi transferido para uma parte mais perigosa / cara do ciclo de desenvolvimento.

Não é uma simplicidade encantadora à sintaxe Lisp-ish. Um dos grandes pontos fortes do Emacs é poder executar o código lisp arbitrário pressionando uma sequência de teclas especial no ponto final de um bloco de código a qualquer momento em qualquer buffer. A natureza simples e delimitada por parênteses da sintaxe lisp torna isso elegante de uma maneira que seria estranha (ter que introduzir chaves)? Na maioria dos outros idiomas. Além disso, a regularidade (function arg, arg...)e o (operator arg, arg...)pensamento sobre funções e operadores como cidadãos de primeira classe e o pensamento sobre funções anônimas são muito naturais, de uma maneira que os operadores infix de outras línguas como Scala não.

Minha experiência limitada com Scala me impede de dizer que a sintaxe é mais simples ou mais legível. Claro, existe alguma sintaxe não lispish no Clojure usando macros, mas minha percepção é que essas macros apenas abrem uma pequena janela para o pensamento imperativo em uma sintaxe que, de outra forma, é muito funcional. Impor uma preferência por sintaxe funcional ou imperativa na linguagem pode simplificar as coisas. Eu precisaria mencionar Clojure, Java e Haskell para isso.

Minha preocupação com Scala é a mesma que tive com C ++ ou Perl (embora em menor grau); a sintaxe da linguagem acomoda vários estilos de pensamento diferentes (Haskell e Java). Isso torna divertido escrever, mas pode ser problemático para facilitar a leitura. Enquanto escrevo isso, lembro que o Clojure suporta idiomas específicos do domínio e me pergunto até que ponto isso prejudica meu argumento.

Sua pergunta é muito interessante. Por fim, a comparação é complexa. Mas, com base no meu conhecimento atual, eu teria que concordar que a sintaxe de Clojure é mais simples que Scala, mas talvez não seja toda uma ordem de magnitude mais simples.

Mesmo que nós os escrevamos com a mesma sintaxe entre parênteses

E essa é basicamente a resposta para sua pergunta.

precisamos aprender como cada um funciona.

Embora seja possível introduzir DSLs com uma sintaxe não tão lispy como o Common Lisps loopusando macros regulares (deixarei as macros de leitor fora disso), elas são usadas principalmente para controlar a avaliação e ainda usarão a sintaxe da expressão s regular. Uma característica importante é que mesmo as loopmacros mais complexas podem ser lidas usando o mesmo velho leitor de sexo.

Embora seja verdade que você terá que aprender sobre as diferentes macros e a forma de entrada que recebem, digamos Common Lisp's, condcom mais aninhados vs. Clojure, condreduzindo uma camada de aninhamento, que não se aplica apenas às macros, mas também para funções regulares. Imagine uma função usual usando uma lista citada de uma estrutura específica como argumento - você ainda terá que se conformar à estrutura de entrada esperada, se a função transformar código, esperar algum tipo de lista, lista, árvore ou algo completamente diferente.

Sempre que encontrar novas funcionalidades, haverá alguma API que você precisará aprender. Isso também seria válido para uma linguagem que permitisse apenas uma function(arg1, arg2, …, argN)sintaxe estrita - você ainda teria que aprender quais são os argumentos esperados, quais efeitos colaterais ocorrem e qual é o resultado de qualquer função.

O que é mais fácil sobre a sintaxe do Lisp, em comparação com uma linguagem como Scale, é que tudo é representado mais ou menos o mesmo, e também que o próprio código usou essas representações e estruturas de dados (que seria a homoiconicidade de que todos estão falando). Essa diferença na complexidade sintática ficaria bem clara se você tentasse escrever um analisador Lisp ou Clojure e depois um analisador Scala. Você terá que lidar com uma gramática muito mais complicada - regras mais complexas sobre precedência, espaço em branco, ambiguidades, mais exceções e assim por diante.

A partir da definição da Wikipedia :

Na ciência da computação, a sintaxe de uma linguagem de programação é o conjunto de regras que define as combinações de símbolos que são considerados programas corretamente estruturados nessa linguagem.

Como o clojure é um cisco, você tem expressões s + a lista de macros do leitor e é tudo.

No scala, você tem classes, classes de caso, lambda implícita com _, palavra-chave implícita, características, anotações genéricas, anotações de variação, etc.

O Clojure possui uma sintaxe mais simples, pois os recursos podem ser implementados como macros ou formulários especiais. Isso é impossível com o scala, nele você deve adicionar sintaxe para suportar alguns recursos.

Macros não são sintaxe.

Discutir a complexidade do ecossistema ou da biblioteca básica é uma discussão completamente diferente.