¿La sintaxis de Clojure es realmente más simple que la de Scala? [cerrado]

El argumento que siempre se hace a favor de Clojure es ese.

La sintaxis es más simple y solo hay una forma de expresar código sin reglas complicadas.

Sin embargo, Scala tiene muchos tipos diferentes de sintaxis y construcciones en comparación con Clojure.

Pero desde la última semana, mientras intentaba aprender Clojure, me di cuenta de que la lista de macros incorporadas es interminable, aunque las escribimos con la misma sintaxis de paréntesis, necesitamos aprender cómo funciona cada una.

Entonces, ¿en qué sentido la sintaxis de Clojure es más simple? Para los LISPers podría ser, pero para las personas de diferentes antecedentes, aprender diferentes construcciones en Scala parece más simple.

Entonces, desde un punto de vista neutral, ¿qué sintaxis es más simple y legible?

Entonces, desde un punto de vista neutral, ¿qué sintaxis es más simple y legible?

Esas son dos preguntas muy diferentes.

Más simple significa "compuesto de menos partes". La sintaxis de Clojure tiene menos reglas, por lo que es objetivamente más simple que la de Scala.

La legibilidad , sin embargo, es subjetiva. Principalmente se reduce a la familiaridad . Por ejemplo, creo que ECMAScript, C #, Java, D, Go, C ++ y C son casi incomprensibles, pero para alguien que está acostumbrado a leer ese tipo de sintaxis, son bastante legibles. Esta parte de la pregunta no puede responderse objetivamente o "desde un punto de vista neutral".

Cuando trabajo en Scala, a menudo hay una fase de mi desarrollo (especialmente con las forcomprensiones) en la que tengo que hacer que todos los tipos funcionen correctamente, lo cual es una gran ventaja para los proyectos grandes, pero definitivamente negativo para los pequeños. Esperaba poder olvidar los tipos y centrarme en "hacer el trabajo" en Clojure de la forma que recuerdo vagamente en Perl o Awk, pero hasta ahora no me ha funcionado de esa manera. Mi experiencia es que, en lugar de "hacer que los tipos funcionen" en la fase de código / compilación, obtengo excepciones cuando intento ejecutar mi código. Esto no es una simplificación; El problema no ha desaparecido, se ha trasladado a una parte más peligrosa / costosa del ciclo de desarrollo.

No es una deliciosa simplicidad a la sintaxis Lisp-ish. Una de las grandes fortalezas de Emacs es poder ejecutar código de barrido arbitrario presionando una secuencia de teclas especial en el par de cierre de un bloque de código en cualquier momento en cualquier búfer. La simple naturaleza delimitada por paréntesis de la sintaxis de lisp lo hace elegante de una manera que sería incómoda (¿tener que introducir llaves?) En la mayoría de los otros idiomas. Además, la regularidad (function arg, arg...)y (operator arg, arg...)hace que pensar en funciones y operadores como ciudadanos de primera clase y pensar en funciones anónimas sea muy natural, de una manera que los operadores infijados de otros idiomas como Scala no lo hacen.

Mi experiencia limitada con Scala me impide decir que la sintaxis es más simple o más legible. Claro, hay una sintaxis no simplista en Clojure usando macros, pero mi percepción es que estas macros solo abren una pequeña ventana al pensamiento imperativo en una sintaxis que de otra manera es muy funcional. Imponer una preferencia por la sintaxis funcional o imperativa en el lenguaje puede simplificar las cosas. Tendría que dar un punto a Clojure, Java y Haskell por esto.

Mi preocupación con Scala es la misma preocupación que tuve con C ++ o Perl (aunque en menor grado); La sintaxis del lenguaje se adapta a varios estilos de pensamiento diferentes (Haskell y Java). Esto hace que sea divertido escribir, pero podría ser problemático para la legibilidad. Incluso mientras escribo eso, recuerdo que Clojure admite lenguajes específicos de dominio y me pregunto en qué medida eso socava mi punto.

Tu pregunta es muy interesante. En última instancia, la comparación es compleja. Pero según mi conocimiento actual, tendría que estar de acuerdo en que la sintaxis de Clojure es más simple que Scala, pero tal vez no sea un orden de magnitud completo más simple.

Aunque los escribimos con la misma sintaxis de paréntesis

Y esa es básicamente la respuesta a tu pregunta.

Necesitamos aprender cómo funciona cada uno.

Si bien es posible introducir DSL con una sintaxis no tan simple como Common Lisps loopusando macros regulares (dejaré las macros de lectura fuera de esto), se usan principalmente para controlar la evaluación, y aún usarán la sintaxis de expresión s regular. Una característica importante es que incluso las loopmacros más complejas pueden leerse usando el mismo viejo lector sexpr.

Si bien es cierto que tendrá que aprender sobre las diferentes macros y la forma de entrada que toman, digamos Common Lisp condcon sus más anidadas frente a Clojure que condreducen una capa de anidamiento, eso no solo es válido para macros, sino también para funciones regulares Imagine una función habitual tomando una lista citada de una estructura particular como argumento: aún tendrá que ajustarse a la estructura de entrada esperada, ya sea que la función transforme el código, espere algún tipo de lista, plist, un árbol o algo completamente diferente.

Cada vez que encuentre una nueva funcionalidad, habrá algunas API que tendrá que aprender. Eso también se aplicaría a un lenguaje que solo permitiera estrictamente la function(arg1, arg2, …, argN)sintaxis: aún tendría que aprender cuáles son los argumentos esperados, qué efectos secundarios ocurren y cuál es el resultado de cualquier función dada.

Lo que es más fácil acerca de la sintaxis de Lisp en comparación con un lenguaje como Scale, es que todo se representa más o menos igual, y también que el código en sí usa estas representaciones y estructuras de datos (esa sería la homoiconicidad de la que todos hablan). Esta diferencia en la complejidad sintáctica se volvería bastante clara si intentara escribir un analizador Lisp o Clojure y luego un analizador Scala. Tendrá que lidiar con una gramática mucho más complicada: reglas más complejas sobre precedencia, espacios en blanco, ambigüedades, más excepciones, etc.

De la definición de Wikipedia :

En informática, la sintaxis de un lenguaje de programación es el conjunto de reglas que define las combinaciones de símbolos que se consideran programas correctamente estructurados en ese lenguaje.

Como clojure es un lisp, tienes expresiones s + la lista de macros de lector y eso es todo.

En scala, tiene clases, clases de casos, lambda implícita con _, palabra clave implícita, rasgos, anotaciones genéricas, anotaciones de varianza, etc.

Clojure tiene una sintaxis más simple porque las características se pueden implementar como macros o formas especiales. Esto es imposible con scala, en su tiene que agregar sintaxis para admitir algunas características.

Las macros no son sintaxis.

Discutir el ecosistema o la complejidad básica de la biblioteca es una discusión completamente diferente.