¿Cuál es la diferencia entre indefinida en Haskell y nula en Java?

Question

Ambos son términos cuyo tipo es la intersección de todos los tipos (deshabitadas). Ambos se pueden transferir en el código sin fallar hasta que un intento para evaluarlos. La única diferencia que veo es que en Java, hay un vacío legal que permite null a ser evaluada por exactamente una sola operación, que es comparación de igualdad de referencia (==) - mientras que en Haskell undefined no se puede evaluar a todos, sin lanzar una excepción. Es esta la única diferencia?

Editar

Lo que realmente estoy tratando de llegar a esta pregunta es, ¿por qué fue incluido en Java null una aparentemente mala decisión, y cómo Haskell escapar de ella? Me parece que el verdadero problema es que se puede hacer algo utilidad con null, es decir, se puede comprobar por nullness . Debido a que se les permite hacer esto, se ha convertido convención estándar para pasar alrededor de los valores nulos en el código y hacer que se indican "ninguna consecuencia" en lugar de "hay un error lógico en este programa". Mientras que en Haskell, no hay manera de comprobar si un plazo evalúa a abajo sin evaluarla y el programa de la explosión, por lo que nunca podría ser utilizado de tal manera para indicar "ninguna consecuencia". En su lugar, uno se ve obligado a usar algo como Maybe.

Lo siento si parece que estoy jugando rápido y suelto con el término "evaluar" ... Estoy tratando de establecer una analogía aquí y tener problemas para expresarlo con precisión. Supongo que es una señal de que la analogía es imprecisa.

Answer 1

¿Cuál es la diferencia entre indefinida en Haskell y nula en Java?

Ok, vamos a retroceder un poco.

"indefinido" en Haskell es un ejemplo de un valor de "abajo" (denotado ?). Tal valor representa cualquier estado indefinido, pegado o parcial en el programa.

Muchas formas diferentes de existir inferior: bucles no de terminación, excepciones, los fallos de concordancia de patrones - básicamente cualquier estado en el programa que no está definido en algún sentido. El valor undefined :: a es un ejemplo canónico de un valor que pone el programa en un estado indefinido.

undefined sí no es particularmente especial - no es por cable en - y se puede aplicar undefined de Haskell usando cualquier expresión que dé abajo. P.ej. esta es una aplicación válida de undefined:

 > undefined = undefined

o salir de inmediato (el viejo compilador Gofer utilizan esta definición):

 > undefined | False = undefined

La propiedad principal del fondo es que si una expresión se evalúa como inferior, todo su programa evaluarán a abajo:. El programa se encuentra en un estado indefinido

¿Por qué quieres un valor tal? Pues bien, en un lenguaje vago, a menudo se pueden manipular las estructuras o funciones que almacenan los valores de fondo, sin el programa propio ser inferior.

por ejemplo. una lista de los bucles infinitos es perfectamente cromulent:

 > let xs = [ let f = f in f 
            , let g n = g (n+1) in g 0
            ]
 > :t xs
 xs :: [t]
 > length xs
 2

Yo simplemente no puede hacer mucho con los elementos de la lista:

 > head xs
 ^CInterrupted.

Esta manipulación de la materia infinita es parte de la razón por diversión así de Haskell y expresivo. Un resultado de la pereza es Haskell presta especial atención a los valores bottom.

Sin embargo, es evidente que el concepto de fondo se aplica igualmente bien a Java, o en cualquier idioma (no total). En Java, hay muchas expresiones que los valores de rendimiento "fondo":

• comparar una referencia contra null (aunque nota, no null en sí, que está bien definido);
• división por cero;
• fuera de límites excepciones;
• un bucle infinito, etc.

simplemente no tienen la capacidad de sustituir una parte inferior para otro con mucha facilidad, y el compilador de Java no hace mucho para razonar acerca de los valores de fondo. Sin embargo, tales valores son allí.

En resumen,

• dereferencing un valor null en Java es una expresión específica que produce un valor inferior en Java;
• el valor undefined en Haskell es una expresión produciendo inferior-genérico que puede ser utilizado en cualquier lugar se requiere un valor inferior en Haskell.

Así es como Son similares.

Postscript

En cuanto a la cuestión de null misma: ¿por qué se considera de mala

• En primer lugar, null de Java es esencialmente equivalente a adición de un Maybe a implícita a cada a tipo en Haskell .
• Desreferenciar null es equivalente a la coincidencia de patrones sólo para el caso Just: f (Just a) = ... a ...

Así que cuando el valor pasado es Nothing (en Haskell), o null (en Java), el programa llega a un estado indefinido. Esto es malo:. El programa se bloquea

Por lo tanto, mediante la adición de null a todos tipo, que acaba de hacer que sea mucho más fácil para crear valores bottom por accidente - los tipos de ayuda que ya no. Su lengua ya no está ayudando a prevenir ese tipo particular de error, y eso es malo.

Por supuesto, otros valores inferiores todavía están allí: excepciones (como undefined), o bucles infinitos. Adición de un nuevo modo de fallo posible todas las funciones - dereferencing null - sólo hace que sea más fácil escribir programas que accidente

.

Answer 2

Su descripción no es del todo correcto. ¿Estás diciendo null no puede ser evaluada. Sin embargo, desde Java es un lenguaje ansiosos, esto significaría que f(null) arrojaría una NPE no importa cuál es la definición de f es (porque los argumentos del método siempre se evalúan antes de ejecutar el método).

La única razón por la que puede pasar alrededor de undefined en Haskell sin obtener una excepción es que Haskell es perezoso y no evalúa argumentos a menos que sea necesario.

Uno más diferencia entre indefinido y nula es que undefined es un valor sencillo se define en la biblioteca estándar. Si no se define en la biblioteca estándar se podría definir por sí mismo (por escrito myUndefined = error "My Undefined por ejemplo).

null En Java es una palabra clave. Si no existiera la palabra clave null, no sería capaz de definirlo (haciendo el equivalente a la definición Haskell, es decir Object myNull = throw(new Exception()), no funcionaría porque la expresión se evalúa allí mismo).