Quelle est la différence entre undefined in Haskell et null en Java?

Question

Les deux sont des termes dont le type est l'intersection de tous les types (inhabitée). Les deux peuvent être passés dans le code sans faillir jusqu'à ce que l'on tente de les évaluer. La seule différence que je peux voir, c'est qu'en Java, il y a une faille qui permet d' null à être évaluée exactement une opération, qui est la référence de comparaison d'égalité (==), alors qu'en Haskell undefined ne peut être évalué sans lancer une exception. Est-ce la seule différence?

Modifier

Ce que je suis vraiment essayer d'obtenir à cette question est, pourquoi était-dont null en Java tels apparemment une mauvaise décision, et comment Haskell échapper? Il me semble que le vrai problème, c'est que vous pouvez faire quelque chose d' utile avec null, à savoir vous pouvez le vérifier pour nullness. Parce que vous êtes autorisés à le faire, il est devenu un standard de convention à passer autour des valeurs null dans le code et de leur indiquer "pas de résultat" au lieu de "il y a une erreur de logique dans ce programme". Alors qu'en Haskell, il n'y a aucun moyen de vérifier si un terme est évaluée à fond sans l'évaluer et le programme de l'explosion, de sorte qu'il ne pourrait jamais être utilisé de manière à indiquer "pas de résultat". Au lieu de cela, on est forcé d'utiliser quelque chose comme Maybe.

Désolé si il me semble que je suis en train de jouer rapide et lâche avec le terme "évaluer"... je suis en train d'établir une analogie ici et avoir de la difficulté à phrasé précis. Je suppose que c'est un signe que l'analogie est imprécis.

Answer 1

Quelle est la différence entre la valeur undefined dans Haskell et null en Java?

Ok, nous allons revenir un peu.

"undefined" en Haskell est un exemple d'un "fond" de la valeur (notée ⊥). Cette valeur représente l'indéfini, coincé ou partielle de l'etat dans le programme.

De nombreuses formes différentes de fond existent: la non-terminaison des boucles, des exceptions, en correspondance du modèle échecs -- pratiquement n'importe quel état dans le programme qui n'est pas définie dans un certain sens. La valeur undefined :: a est un exemple canonique d'une valeur qui met le programme dans un état indéfini.

undefined lui-même n'est pas particulièrement spécial -- ses pas câblé, et vous pouvez mettre en œuvre Haskell undefined à l'aide de tout le bas-rendement de l'expression. E. g. c'est un valide la mise en œuvre de l' undefined:

 > undefined = undefined

Ou quitter immédiatement (la vieille bonne à tout faire compilateur utilisé cette définition):

 > undefined | False = undefined

La propriété principale de fond est que si une expression est évaluée à fond, l'ensemble de votre programme permettra d'évaluer à fond: le programme est dans un état indéfini.

Pourquoi voudriez-vous une telle valeur? Eh bien, dans un paresseux de la langue, vous pouvez souvent manipuler des structures ou des fonctions que le magasin de fond des valeurs, sans que le programme lui-même en bas.

E. g. une liste de boucle infinie est parfaitement cromulent:

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

Je ne peux pas faire grand chose avec les éléments de la liste:

 > head xs
 ^CInterrupted.

Cette manipulation de l'infini des choses est en partie pourquoi Haskell est tellement amusant et expressive. À la suite de la paresse est Haskell accorde une attention toute particulière à l' bottom valeurs.

Cependant, clairement, le concept de fond s'applique aussi bien à la Java, ou tout (non totale) de la langue. En Java, il existe de nombreuses expressions qui donnent "bas" valeurs:

• la comparaison d'une référence null (si pas d' null lui-même, qui est bien défini);
• la division par zéro;
• hors-limites des exceptions;
• une boucle infinie, etc.

Vous n'avez tout simplement pas la capacité de remplacer un fond pour une autre très facilement, et le compilateur Java ne fait pas beaucoup de raison, sur fond de valeurs. Toutefois, ces valeurs sont là.

En résumé,

• référence à un null de la valeur en Java est une expression qui produit une valeur inférieure en Java;
• l' undefined de la valeur en Haskell est un générique de bas rendement expression qui peut être utilisé partout où une valeur inférieure est nécessaire en Haskell.

C'est la façon dont ils sont similaires.

Postscript

Quant à la question de l' null lui-même: pourquoi il est considéré comme une mauvaise forme?

• Tout d'abord, Java null est essentiellement équivalent à l'ajout d'un implicite Maybe a pour chaque type a en Haskell.
• Un déréférencement null est équivalent à la correspondance de modèle que pour l' Just cas: f (Just a) = ... a ...

Ainsi, lorsque la valeur transmise est - Nothing (en Haskell), ou null (en Java), votre programme atteint un état indéfini. Ce qui est mauvais: votre programme est en panne.

Donc, en ajoutant null pour chaque type, vous avez tout à fait, il est beaucoup plus facile de créer bottom valeurs par accident -- les types plus vous aider. Votre langue n'est plus vous aider à éviter ce genre d'erreur, et que c'est mal.

Bien sûr, les autres valeurs sont toujours là: les exceptions (comme undefined) , ou les boucles infinies. Ajout possible d'un mode de défaillance pour chaque fonction -- déréférencement null -- tout simplement qu'il est plus facile d'écrire des programmes qui plantent.

Answer 2

Votre description n'est pas tout à fait correct. Vous êtes en train de dire null ne peut être évalué. Toutefois, depuis java est un enthousiaste de la langue, cela signifierait qu' f(null) jeter un NPE quelle que soit la définition de l' f est (parce que la méthode arguments sont toujours évaluées avant que la méthode fonctionne).

La seule raison pour laquelle que vous pouvez passer autour de undefined en haskell sans se faire une exception, c'est que haskell est paresseux et n'a pas d'évaluer des arguments sauf si nécessaire.

Une autre différence entre indéfini et la valeur null est qu' undefined est une simple valeur définie dans la bibliothèque standard. Si ce n'était pas défini dans la bibliothèque standard, vous pouvez définir vous-même (par écrit, myUndefined = error "My Undefined par exemple).

En Java, null est un mot-clé. Si il n'y avait pas null mot-clé, vous ne seriez pas capable de le définir (fait l'équivalent d'haskell définition, c'est à dire Object myNull = throw(new Exception()), ne fonctionne pas car l'expression est évaluée là).