¿Qué idiomas tipificados estáticamente son similares a Python?

Python es el idioma más bonito que conozco actualmente, pero la tipificación estática es una gran ventaja debido a la autocompletación (aunque existe un soporte limitado para los lenguajes dynamics, no es nada comparado con el que se admite en estática). Tengo curiosidad por saber si hay algún idioma que intente agregar los beneficios de Python a un lenguaje de tipo estático. En particular me interesan los idiomas con características como:

  • Soporte de syntax: como el de los diccionarios, las comprensiones de matrices.
  • Funciones: argumentos de palabras clave, cierres, tupla / valores de retorno múltiples
  • Modificación en tiempo de ejecución / creación de clases.
  • Evitar especificar clases en todas partes (en Python esto se debe a la tipificación de pato, aunque la inferencia de tipos funcionaría mejor en un lenguaje tipado estáticamente)
  • Soporte de metaprogtwigción: esto se logra en Python a través de la reflexión, anotaciones y metaclases.

¿Hay idiomas tipificados estáticamente con un número significativo de estas características?

Boo es un lenguaje escrito de forma estática para la infraestructura de lenguaje común (también conocida como la plataforma Microsoft .NET). La syntax está muy inspirada en Python, y hashes / lists / array son parte de la syntax:

i = 5 if i > 5: print "i is greater than 5." else: print "i is less than or equal to 5." hash = {'a': 1, 'b': 2, 'monkey': 3, 42: 'the answer'} print hash['a'] print hash[42] for item in hash: print item.Key, '=>', item.Value 

Cobra es un lenguaje estático para el CLR (como Boo). Desde su página web:

Cobra es un lenguaje de progtwigción de propósito general con:

  - a clean, high-level syntax - static and dynamic binding - first class support for unit tests and contracts - compiled performance with scripting conveniences - lambdas and closures - extensions and mixins - ...and more 
 Sample code: """ This is a doc string for the whole module. """ class Person """ This is a class declaration. """ var _name as String # declare an object variable. every instance of Person will have a name var _age as int cue init(name as String, age as int) _name = name _age = age def sayHello # This is a method # In strings, anything in brackets ([]) is evaluated as an expression, # converted to a string and substituted into the string: print 'Hello. My name is [_name] and I am [_age].' def add(i as int, j as int) as int """ Adds the two arguments and returns their sum. """ return i + j 

Aunque no está orientado a objetos, Haskell ofrece un número significativo de las características que le interesan:

  • Compatibilidad con syntax para listas de comprensión, además de notación para una amplia variedad de construcciones de secuenciación / enlace. (El soporte de syntax para diccionarios está limitado a listas de pares, por ejemplo,

     dict = ofElements [("Sputnik", 1957), ("Apollo", 1969), ("Challenger", 1988)] 
  • Las funciones admiten cierres completos y múltiples valores de retorno utilizando tipos de tuplas. Los argumentos de palabras clave no son compatibles, pero a veces se puede sustituir una poderosa característica de “argumentos implícitos”.

  • Sin modificación en tiempo de ejecución de clases, tipos u objetos.

  • Evitar la especificación de clases / tipos en todas partes a través de la inferencia de tipos .

  • Metaprogtwigción utilizando plantilla Haskell.

Además, para que te sientas como en casa, Haskell tiene sangrado significativo.

De hecho, creo que Haskell tiene una sensación muy diferente de Python en general, pero eso se debe principalmente al sistema de tipo estático extremadamente poderoso. Si estás interesado en probar un lenguaje de tipo estático, Haskell es uno de los más ambiciosos que existen en este momento.

Puede que no coincida con todas sus necesidades, pero eche un vistazo a Boo, el lenguaje de muñeca para la CLI

Si lo hace, recomiendo DSL en Boo: Lenguajes específicos de dominio en .NET, que, aparte de los aspectos de DSL, cubre la syntax de Boo en un apéndice muy bueno y una gran cantidad de meta-progtwigción.

Además los tutoriales son un gran recurso.

El lenguaje de progtwigción Go. He visto algún paradigma similar.

Rpython es un subconjunto de Python que se escribe de forma estática.

El lenguaje de progtwigción D es un lenguaje comstackdo de forma nativa y estático que tiene algunas características significativas inspiradas en Python.

Arrays y arrays asociativos están integrados en el lenguaje. No hay listas de comprensión, pero las bibliotecas std.range y std.algorithm llenan gran parte de ese vacío. Por ejemplo, aquí hay una manera de resumir todos los números pares de 0 a 100 en D:

 auto result = reduce!"a + b"( filter!"a % 2 == 0"( iota(0, 100) ) ); 

No hay argumentos de palabras clave hasta ahora, pero los cierres están ahí. Las tuplas son compatibles, pero no se descomprimen automáticamente.

En D, evita la especificación de clases (y tipos en general) en todas partes con la palabra clave auto y con las plantillas. Por ejemplo, aquí hay un código genérico para encontrar el producto de una matriz de cualquier tipo numérico:

 // The return type of product() is inferred. auto product(T)(T[] array) { T ret = 1; foreach(num; array) { // typeof(num) is inferred. ret *= num; } return ret; } 

El soporte de metaprogtwigción de D consiste en la introspección de tiempo de comstackción (por ejemplo, puede iterar sobre los campos de una clase o estructura en tiempo de comstackción), información de tipo de tiempo de ejecución y plantillas que están realmente diseñadas para la metaprogtwigción más allá de los generics simples. Por ejemplo, aquí se explica cómo escribir una función genérica que genera una operación de comparación predeterminada para dos estructuras, lo cual es útil si necesita un ordenamiento total arbitrario para algo como un árbol binario:

 /**Returns -1 if lhs < rhs, 0 if lhs == rhs, 1 if lhs > rhs.*/ int compareStructs(T)(T lhs, T rhs) { foreach(tupleIndex, value; lhs.tupleof) { if(value < rhs.tupeof[tupleIndex]) { return -1; } else if(value > rhs.tupleof[tupleIndex]) { return 1; } } return 0; } 

La autocompletación aún es posible en un lenguaje tipificado dinámicamente; nada impide que el IDE realice una inferencia de tipo o inspección, incluso si la implementación del lenguaje no lo hace.

Si lo que estás buscando es completar automáticamente, entonces querrás quedarte con Python y usar un gran IDE en su lugar.

Pruebe PyCharm: http://www.jetbrains.com/pycharm/index.html

A menos que esté codificando algunas cosas extremadamente dinámicas (que de todos modos probablemente no pueda hacer en un lenguaje estático), se mantendrá al día con el código y le dará información completa, refactorización y todas las otras cosas a las que estamos acostumbrados en idiomas tipificados estáticamente.

Puede dar sugerencias de tipo al IDE donde realmente lo necesita haciendo:

 def foo(bar): if 0: bar = Bar() # "if 0" will be removed from the bytecode automatically by python bar. # will now autocomplete 

Lobster ( http://strlen.com/lobster/ ) es un lenguaje de progtwigción tipificado estáticamente con syntax Python-esque.

Tiene algunas cosas que estás pidiendo:

  • Inferencia de tipos, por lo que su código puede parecerse a Python sin tener que especificar tipos en todas partes. De hecho, va más allá con la inferencia de tipos que lenguajes como Haskell.
  • Cierres: son sintácticamente más ligeros que Python (cree sus propias estructuras de control) y aún más potentes (puede ser multilínea, puede regresar de ellos a las funciones adjuntas).
  • Múltiples valores de retorno.

No funciona tan bien en estos artículos:

  • Sintaxis para diccionarios o matrices de comprensión. Aunque su syntax para el mapa / filtro es tan mínima que probablemente pueda competir con las comprensiones de matriz.
  • Argumentos con palabras clave actualmente solo para constructores.
  • Modificación en tiempo de ejecución de las clases: nop … es un lenguaje bastante estático.
  • Reflexión: también no, aunque esto sería ciertamente posible.

Creo que Eric y PyScripter tienen un buen autocompletado en Windows, pero tal vez no sea tan bueno como PyTools para Visual Studio (Express).

Para la escritura estática en Python, usaría Cython: http://docs.cython.org/src/quickstart/cythonize.html