¿Cómo hacer que estas funciones tipadas dinámicamente sean seguras?

¿Hay algún lenguaje de programación (o sistema de tipo) en el que pueda expresar las siguientes funciones de Python de forma estática y segura (sin tener que usar moldes, verificaciones de tiempo de ejecución, etc.)?¿Cómo hacer que estas funciones tipadas dinámicamente sean seguras?

#1:

# My function - What would its type be? 
def Apply(x): 
    return x(x) 

# Example usage 
print Apply(lambda _: 42)

#2:

white = None 
black = None 

def White(): 
    for x in xrange(1, 10): 
     print ("White move #%s" % x) 
     yield black 

def Black(): 
    for x in xrange(1, 10): 
     print ("Black move #%s" % x) 
     yield white 

white = White() 
black = Black() 

# What would the type of the iterator objects be? 
for it in white: 
    it = it.next()

Fuente

2009-07-03 Dario

¿Es esta tarea? –

¡No! ¿Por qué piensas eso? – Dario

Estas deberían ser en dos preguntas separadas. Las consecuencias de que estén en la misma pregunta son evidentes, ya que la mayoría de las respuestas a continuación abordan cualquiera de los dos, pero no ambas. Por lo tanto, se cierra como _demasiado_. – rightfold

1 # No se puede escribir con un tipo finito. Esto significa que muy pocos (si alguno) lenguajes de programación podrán escribir esto.

Sin embargo, como han demostrado, hay un tipo específico de X que permite que la función que se ha proporcionado:

x :: t -> B

Dónde B es algún tipo de hormigón. Este resultado en apply se escriben como:

apply :: (t -> B) -> B

Tenga en cuenta que Hindley-Milner no obtendrá este tipo.

2 # Esto es fácil de representar en Haskell (se deja como ejercicio para el lector ...)

Fuente

2009-07-03 13:07:51 jwoolard

A # 2: ¿Podría dar un ejemplo concreto? Creo que uno implementaría esto en Haskell de una manera bastante diferente (mónadas/continuaciones), ¿pero no escribiría los iteradores sería el mismo problema que en el # 1? – Dario

Cuando se trata de ejemplo # 1, que tendría que especificar el tipo de retorno de Aplicar(), y luego todas las funciones x que pasar también debe devolver esto. La mayoría de los idiomas con tipado estático no podrían hacerlo de manera segura sin controles, ya que la función x que ingresas puede devolver lo que sea.

En el ejemplo n. ° 2, el tipo de objetos del iterador es que son iteradores. Si te refieres a lo que devuelven, devuelven iteradores. No veo por qué eso no sería posible en un sistema estático, pero tal vez me falta algo.

Fuente

2009-07-03 12:41:53

Los iteradores también son genéricos ya que necesita saber el tipo del valor que contiene (iterador ). – Dario

contiene? ¿Por qué? Necesitas saber qué devuelven, y en este caso devuelven otro iterador. –

Espera, quieres decir que no podemos estar seguros de que el iterador que devuelve el iterador devuelve un iterador, y eso es cierto. En resumen, no, en un lenguaje estático, si usa funciones genéricas y las pasa, entonces no, no sabe qué devuelven. De hecho, esto es típicamente algo que haces en un lenguaje estático cuando terminas necesitando funcionalidad dinámica. ;) –

he encontrado una solución para Haskell # 1 usando Rank-N-Types (sólo para GHCi)

{-# LANGUAGE RankNTypes #-} 
apply :: (forall a . a -> r) -> r 
apply x = x x 

apply $ const 42 -- Yields 42

Fuente

2009-11-25 15:13:34 Dario

¿Cómo hacer que estas funciones tipadas dinámicamente sean seguras?

Respuesta

Cuestiones relacionadas