sirve - ¿Qué lenguajes tipados estáticamente son similares a Python?

python pdf

Question

Python es el mejor lenguaje que conozco actualmente, pero el tipado estático es una gran ventaja debido a la finalización automática (aunque hay soporte limitado para lenguajes dinámicos, no es nada comparado con el soportado en estática). Tengo curiosidad por saber si hay algún idioma que intente agregar los beneficios de Python a un lenguaje estáticamente tipado. En particular, soy interesante en idiomas con características como:

• Soporte de sintaxis: como el de diccionarios, comprensiones de matriz
• 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 tipa de pato, aunque la inferencia de tipo funcionaría mejor en un lenguaje estáticamente tipado)
• Soporte de metaprogramación: esto se logra en Python a través de la reflexión, anotaciones y metaclases

¿Hay algún lenguaje estáticamente tipado con un número significativo de estas características?

Answer 1

Aunque no está orientado a objetos, Haskell ofrece una cantidad significativa de las características que le interesan:

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

  dict = ofElements [("Sputnik", 1957), ("Apollo", 1969), ("Challenger", 1988)]

• Las funciones admiten cierres completos y valores de retorno múltiples utilizando tipos de tuplas. Los argumentos de palabra clave no son compatibles, pero una característica poderosa de "argumentos implícitos" a veces puede sustituir.

• No hay modificaciones de tiempo de ejecución de clases, tipos u objetos.

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

• Metaprogramación con la plantilla Haskell.

Además, para que te sientas como en casa, ¡Haskell tiene una sangría significativa!

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

Answer 2

Creo que Eric y PyScripter tienen una buena autocompletación en Windows, pero quizás no tanto como PyTools para Visual Studio (Express).

Para el tipado estático en Python, usaría Cython: http://docs.cython.org/src/quickstart/cythonize.html

Answer 3

El lenguaje de programación D es un lenguaje compilado nativamente, tipado estáticamente, que tiene algunas características importantes inspiradas en Python.

Las matrices y matrices asociativas están integradas en el lenguaje. No hay listas de comprensión, pero las bibliotecas std.range y std.algorithm ocupan 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)
    )
);

Hasta ahora no hay argumentos clave, pero los cierres están ahí. Las tuplas son compatibles, pero no se desempaquetan automáticamente.

En D, evita especificar clases (y tipos en general) en todas partes con la palabra clave auto y con plantillas. Por ejemplo, aquí está el código genérico para encontrar el producto de la 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 metaprogramación de D consiste en introspección en tiempo de compilación (por ejemplo, puede iterar sobre los campos de una clase o estructura en tiempo de compilación), información del tipo de tiempo de ejecución y plantillas que están realmente diseñadas para la metaprogramación más allá de los genéricos simples. Por ejemplo, a continuación se explica cómo escribir una función genérica que genera una operación de comparación predeterminada para dos estructuras, que es útil si necesita un orden total arbitrario para algo así 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;
}

Answer 4

El lenguaje de programación Go. He visto un paradigma similar.

Answer 5

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

Answer 6

Puede no coincidir con todas sus necesidades, pero eche un vistazo a Boo - El lenguaje amigable para la CLI

Si lo haces, recomiendo las DSL en Boo: Idiomas Específicos de Dominio en .NET que, aparte de los aspectos DSL, cubren la sintaxis de Boo en un muy buen apéndice y una gran cantidad de meta-programación.

Además, los tutorials son un gran recurso.

Answer 7

Rpython es un subconjunto de Python que está tipado estáticamente.

Answer 8

Si lo que está buscando es la autocompletación, entonces puede quedarse con Python y usar un IDE excelente.

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

A menos que esté codificando algunas cosas extremadamente dinámicas (que probablemente no podrá hacer en un lenguaje estático de todos modos), se mantendrá al día con el código y le dará finalización, refactorización y todas las otras ventajas a las que estamos acostumbrados en los lenguajes estáticos.

Puede dar mecanografías 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

Answer 9

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

Cobra es un lenguaje de programació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

Answer 10

Boo es un lenguaje estáticamente tipado para Common Language Infrastructure (también conocido como la plataforma Microsoft .NET). La sintaxis está altamente inspirada en Python, y hashes / lists / array son parte de la sintaxis:

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