¿Es posible tener un lenguaje escrito dinámicamente sin pato? [cerrado]

_{Esta pregunta se hizo aquí , pero recibió respuestas pobres y no aclaró el problema. Creo que justifica pedirlo de nuevo.}

Entiendo que puede escribir pato con lenguajes dinámicamente o estáticamente (pero los ejemplos de estos son raros, como las plantillas de C ++).

Sin embargo, no estoy seguro de si existe un lenguaje escrito dinámicamente sin tipear pato.

La escritura de pato significa que el tipo de un objeto se basa en las operaciones y los atributos que tiene en un momento dado. ¿Hay alguna forma de escribir dinámicamente sin admitir inevitablemente la escritura de pato?

Veamos este código de Python para el examen:

def func(some_object)
    some_object.doSomething()

something = Toaster()
func(something)

En lenguajes de tipo dinámico, el tipo de un objeto solo se conoce en tiempo de ejecución. Entonces, cuando intentas hacer una operación en él (p some_object.doSomething(). Ej. ), El tiempo de ejecución solo tiene una opción , que es verificar si el tipo de some_objectsoporte es doSomething(), o no , exactamente qué tipo de pato es.

Entonces, ¿es posible tener un lenguaje escrito dinámicamente sin escribir pato? Por favor explique.

Primero, para asegurarme de que estamos hablando de las mismas cosas, comenzaría con algunas definiciones.

La escritura estática significa que los errores de tipo se informan en tiempo de compilación, mientras que la escritura dinámica significa que los errores de tipo se informan en tiempo de ejecución.

La escritura de pato significa que un fragmento de código requiere que un objeto admita las operaciones que se utilizan y nada más.

La tipificación estructural requiere que un objeto admita un conjunto dado de operaciones (incluso si algunas de ellas no se pueden usar).

La tipificación nominal requiere que el objeto sea exactamente del tipo dado, o sea un subtipo de ese tipo.

Entonces, como puede ver, la tipificación estructural es más estricta que la tipificación de pato y la tipificación nominal es más estricta que la estructural.

Ahora, voy a hablar sobre el lenguaje TypeScript , porque ilustra muy bien la mayoría de estas opciones.

Considere el siguiente programa TypeScript:

interface Person {
    Name : string;
    Age : number;
}

function greet(person : Person) {
    alert("Hello, " + person.Name);
}

greet({ Name: "svick" });

Dado que el objeto al que se pasa greetno tiene la Agepropiedad, esto provoca un error de tiempo de compilación, lo que demuestra que TypeScript usa escritura estructural estática .

A pesar del error, el código anterior se compila en el siguiente JavaScript, que funciona bien:

function greet(person) {
    alert("Hello, " + person.Name);
}

greet({ Name: "svick" });

Esto muestra que TypeScript también utiliza la escritura dinámica de pato .

Si el código en su lugar se compila a algo como:

function greet(person) {
    if (!(typeof(person.Name) == 'string' && typeof(person.Age) == 'number'))
        throw 'TypeError';

    alert("Hello, " + person.Name);
}

Entonces ese sería un ejemplo de tipificación estructural dinámica , porque verifica que el objeto tenga las propiedades requeridas de los tipos requeridos, incluso si la función en sí no los requiere.

Si se compiló para:

function greet(person) {
    if (!(person instanceof Person))
        throw 'TypeError'

    alert("Hello, " + person.Name);
}

Ese sería un ejemplo de tipificación nominal dinámica , porque verifica el nombre del tipo del objeto, no su estructura.

Lo que todo esto muestra es que es posible la tipificación dinámica sin pato (tanto estructural como nominal). Pero este enfoque no se usa con mucha frecuencia, porque combina principalmente las desventajas de la escritura sin pato (debe especificar los tipos explícitamente; menos flexible) y la escritura dinámica (los errores de tipo solo se muestran en tiempo de ejecución y solo en el código que realmente se ejecuta )

Si va a agregar anotaciones de tipo para hacer posible la escritura sin pato, también puede verificar los tipos en el momento de la compilación.

Aparentemente (por lo que leí), la escritura de pato solo tiene significado en un contexto orientado a objetos, cuando las funciones se adjuntan como métodos a los objetos. Luego, cuando escriba duck.quacks(3), esto funcionará si el valor actual de ducktiene el método quacks.

La escritura dinámica no está necesariamente asociada a una vista OO con métodos.

Puede definir el tipo realcon el operador o la función asociados +: real*real->real, y el tipo rationalcon el operador asociado +: rational*rational->rational. Luego, si escribe a+b, en un sistema de tiempo verificado dinámicamente, ambas variables ay bpueden tener un +operador, pero obtiene un error de tipo de tiempo de ejecución.

La tipificación dinámica verifica la consistencia categorial de los valores, posiblemente varios de ellos.

Duck Typing comprueba la consistencia del comportamiento del código con un objeto en mano (uno solo, por lo que yo entiendo).

En cierto sentido, la tipificación de pato es una forma de polimorfismo de tiempo de ejecución, excepto por el hecho de que solo se aplica a los métodos de acceso de un solo objeto.

Sin embargo, uno podría definir una forma más general de polimorfismo en tiempo de ejecución, donde el operador +a ejecutar se determinaría sobre la base de todos los argumentos. Para que un pato y un pollo puedan bailar juntos si comparten una función de baile común. Podrían tener varios para que los patos puedan bailar también con gansos con una función diferente. Pero eso parece un poco complicado. Hasta donde recuerdo, algo parecido (con probablemente más estructura) pudo haber sido posible con las funciones genéricas del lenguaje EL1 , un precursor muy antiguo de lenguajes orientados a objetos.

Una respuesta por analogía:

¿Puedes comprar un convertible y nunca poner la capota baja? Por supuesto. Probablemente no sea la mejor manera de gastar sus recursos, ya que se le paga extra por algunas características (por ejemplo, capota convertible, rigidez estructural adicional debido a la falta de techo como elemento estructural) y obtiene algunos peores resultados (por ejemplo, ruido adicional de la carretera, posiblemente menor seguridad contra choques, compartimentos de almacenamiento más pequeños) como resultado de invertir en esa característica que no usará. Pero es técnicamente factible.

Es lo mismo con los lenguajes dinámicos y la escritura de pato. Has renunciado a la mayor eficiencia y a las garantías de seguridad de tipo de tiempo de compilación de los lenguajes estáticos. ¿Para qué? Generalmente por la simplicidad de la escritura de patos. Las variables y las colecciones pueden contener cualquier cosa, y no es necesario que hagas mucho por adelantado especificando exactamente qué. Las colecciones mixtas como [ 12, "gumbo", 12.4, 4+4j ](un número entero, una cadena, un valor de coma flotante y un valor complejo) son triviales y no tiene la conversión de tipos constante que ve en el código Java (por ejemplo).

Es posible en un lenguaje dinámico como Python crear objetos que no están tipificados en pato:

class Hungarian(object):
    self __init__(self):
        self.value = []
    self addInt(self, intValue):
        self.value.append(intValue)
    self addFloat(self, floatValue):
        self.value.append(floatValue)
    self addComplex(self, complexValue):
        self.value.append(complexValue)
    # ...

Pero como puede observar, no hay una verificación real de los tipos, y cada uno de los métodos se implementa con una estructura incorporada de tipo pato ( list). Habiendo pagado el precio por el dinamismo, también podrías bajar la capota y obtener la simplicidad resultante:

class NotHungarian(object):
    def __init__(self):
        self.value = []
    def add(self, whatever):
        self.value.append(whatever)