Inconvénients du système de type Scala par rapport à Haskell?

J’ai lu que l’interopérabilité de Java affaiblit le système de types de Scala et ne peut donc pas exécuter certaines des mêmes puissances que le système de types de Haskell. Est-ce vrai? Est-ce que la faiblesse est due à un effacement de type, ou est-ce que je me trompe à tous égards? Est-ce que cette différence est la raison pour laquelle Scala n’a pas de classe de classe?

La grande différence est que Scala n’a pas d’inférence de type global Hindley-Milner et utilise à la place une forme d’inférence de type local, vous obligeant à spécifier des types pour les parameters de méthode et le type de retour pour les fonctions surchargées ou récursives.

Cela ne dépend pas du type d’effacement ou d’autres exigences de la JVM. Toutes les difficultés possibles ici peuvent être surmontées, et considérez Jaskell – http://docs.codehaus.org/display/JASKELL/Home

L’inférence HM ne fonctionne pas dans un contexte orienté object. Plus précisément, lorsque le polymorphism de type est utilisé (par opposition au polymorphism ad hoc des classes de type). Ceci est crucial pour un interopérabilité fort avec d’autres bibliothèques Java et (dans une moindre mesure) pour obtenir la meilleure optimisation possible à partir de la JVM.

Il n’est pas vraiment valable d’affirmer que Haskell ou Scala ont un système de type plus fort, mais simplement qu’ils sont différents. Les deux langues repoussent les limites de la programmation basée sur les types dans différentes directions, et chaque langage possède des atouts uniques difficiles à reproduire dans l’autre.

Le système de typage de Scala est différent de celui d’Haskell, bien que les concepts de Scala soient parfois directement inspirés des forces de Haskell et de sa communauté de chercheurs et de professionnels compétents.

Bien sûr, l’exécution sur une machine virtuelle qui n’est pas principalement destinée à la functional programming crée des problèmes de compatibilité avec les langues existantes ciblant cette plate-forme. Comme la plupart des raisonnements sur les types se produisent au moment de la compilation, les limitations de Java (en tant que langage et en tant que plate-forme) à l’exécution ne sont pas préoccupantes (sauf Type Erasure, bien que ce bogue semble faire l’intégration à Java) écosystème plus homogène).

Pour autant que je sache, le seul “compromis” au niveau système avec Java est une syntaxe spéciale pour gérer les types bruts. Bien que Scala n’autorise même plus les types bruts, il accepte les anciens fichiers de classes Java avec ce bogue. Peut-être avez-vous vu du code comme List[_] (ou l’équivalent plus long List[T] forSome { type T } ). Ceci est une fonctionnalité de compatibilité avec Java, mais est traitée en interne comme un type existentiel et n’affaiblit pas le système de types.

Le système de type Scala prend en charge les classes de type , bien que de manière plus verbeuse que Haskell. Je suggère de lire cet article, qui pourrait créer une impression différente sur la force relative du système de types de Scala (le tableau de la page 17 constitue une belle liste de concepts de systèmes de types très puissants).

L’approche utilisée par les compilateurs de Scala et de Haskell pour inférer des types n’est pas nécessairement liée à la puissance du système de types, bien qu’elle ait un impact sur la manière dont les gens écrivent du code. Avoir un puissant algorithme d’inférence de type peut être intéressant pour écrire plus de code abstrait (vous pouvez décider vous-même si c’est une bonne chose dans tous les cas).

Au final, le système de caractères de Scala et de Haskell est motivé par le désir de fournir à ses utilisateurs les meilleurs outils pour résoudre leurs problèmes, mais ils ont emprunté des voies différentes pour y parvenir.

Un autre point intéressant à considérer est que Scala supporte directement le style OO classique. Ce qui signifie qu’il existe des relations de soustype (par exemple, List est une sous-classe de Seq). Et cela rend l’inférence de type plus délicate. Ajoutez à cela le fait que vous pouvez mélanger des traits dans Scala, ce qui signifie qu’un type donné peut avoir plusieurs relations de supertype (le rendant encore plus délicat)

Scala n’a pas de type rang n , bien qu’il soit possible de contourner cette limitation dans certains cas.

Je n’ai que peu d’expérience avec Haskell, mais la chose la plus évidente que je remarque est qu’un système de type Scala différent de Haskell est l’inférence de type.

Dans Scala, il n’y a pas d’inférence de type global, vous devez explicitement indiquer le type d’arguments de fonction.

Par exemple, dans Scala, vous devez écrire ceci:

 def add (x: Int, y: Int) = x + y 

au lieu de

 add xy = x + y 

Cela peut poser problème lorsque vous avez besoin d’une version générique de la fonction add qui fonctionne avec tous les types de fichiers avec la méthode “+”. Il y a une solution de contournement pour cela, mais il sera plus détaillé.

Mais dans la réalité, j’ai trouvé que le système de type Scala était assez puissant pour une utilisation quotidienne, et je n’utilise presque jamais ces solutions de contournement pour les applications génériques, peut-être parce que je viens du monde Java.

Et la limitation de la déclaration explicite du type d’argument n’est pas forcément une mauvaise chose, vous avez besoin de la documenter quand même.

Eh bien, est-ce que Turing est réductible?

Voir la page d’ Ook Kiselyov http://okmij.org/ftp/ … On peut implémenter le calcul lambda dans le système de type Haskell. Si Scala peut le faire, alors, dans un sens, le système de types de Haskell et le système de types de Scala calculent les mêmes types. Les questions sont les suivantes: à quel point l’un est-il naturel? Comment élégant est l’un sur l’autre?