Quelles sont les différences et les similitudes entre les systèmes de types Scala et Haskell?

Question

Comment expliquer le système de typage Scala à un expert Haskell? Quels exemples montrent les avantages de Scala?

Comment expliquer le système de typographie de Haskell à un praticien avancé en Scala? Que peut-on faire à Haskell et qui ne peut pas être fait à Scala?

Answer 1

Scala À un programmeur Haskell:

Scala est un langage strict et impur avec des modules de première classe. Les types de données sont déclarés comme "classes". ou " traits " avec des différences subtiles, et des modules ou "objets" sont des valeurs de ces types. Scala prend en charge les constructeurs de type prenant des paramètres de type universellement quantifiés. Les objets / classes / traits ont des membres constitués de valeurs, de variables mutables et de fonctions (appelées "méthodes", auxquelles le module est implicitement transmis en tant que variable appelée this ). Les modules peuvent avoir des membres de type pouvant également prendre des paramètres. Les membres de type sont quantifiés de manière existentielle et les paramètres de type peuvent être de type supérieur. Comme les types peuvent appartenir à des valeurs de première classe, Scala fournit une sorte de typage dépendant appelé types dépendants du chemin .

Les fonctions de première classe sont également des modules. Une fonction est un module avec une méthode nommée apply . Une méthode n'est pas de première classe, mais une syntaxe est fournie pour envelopper une méthode dans une fonction de première classe. Malheureusement, un module requiert tous ses paramètres de type à l’avance; par conséquent, une fonction de première classe partiellement appliquée n’est pas autorisée à être quantifiée de manière universelle. Plus généralement, Scala manque complètement de mécanisme direct pour les types de rang supérieurs à 1, mais des modules paramétrés sur des types plus gentils peuvent être exploités pour simuler des types de rang n.

Au lieu de classes de types avec une portée globale, Scala vous permet de déclarer une valeur implicite d’un type donné. Cela inclut les types de fonction, qui fournissent une conversion implicite, et donc une extension de type. En plus des conversions implicites, l’extension de type est fournie par le signe "rallonge". mécanisme qui vous permet de déclarer une relation sous-type / supertype entre les modules. Ce mécanisme peut être utilisé pour simuler des types de données algébriques dans lesquels le supertype peut être considéré comme le type situé à gauche d'une déclaration de données et ses sous-types comme les constructeurs de valeur situés à droite. Scala dispose de fonctionnalités étendues de correspondance de modèles utilisant un matcher de modèles virtualisé avec des modèles de première classe.

Scala prend en charge le sous-typage, ce qui limite considérablement l’inférence de type. Mais l'inférence de type s'est améliorée avec le temps. L'inférence de types de type supérieur est prise en charge. Cependant, la Scala ne dispose d'aucun système de type significatif, et n'a donc aucune inférence ni aucune unification de type. Si une variable de type est introduite, elle est du type * , sauf indication contraire. Certains types tels que Any (le supertype de tous les types) et Nothing (un sous-type de chaque type) sont techniquement de tous les types bien qu'ils ne puissent pas l'être. appliqué aux arguments de type.

Haskell à un programmeur Scala:

Haskell est un langage purement fonctionnel. Cela signifie que les fonctions ne sont autorisées à avoir aucun effet secondaire. Par exemple, un programme Haskell n'imprime pas à l'écran en tant que tel, mais est une fonction qui renvoie une valeur du type de données IO [_] qui décrit une séquence d'actions à effectuer par le sous-système IO. .

Attendu que Scala est strict par défaut et fournit "par nom". Annotation pour les arguments de fonction non restrictifs, Haskell est paresseux par défaut en utilisant "par besoin". sémantique et fournit des annotations pour les arguments stricts.

L'inférence de type dans Haskell est plus complète que dans Scala, avec une inférence complète. Cela signifie que les annotations de type ne sont presque jamais nécessaires.

Les extensions récentes du compilateur GHC permettent des fonctionnalités de système de type avancées qui n'ont pas d'équivalent dans Scala, telles que les types de rang-n, les familles de types et le polymorphisme des types.

En Haskell, un module est un ensemble de types et de fonctions, mais les modules ne sont pas des entités de première classe. Les implicites sont fournis par les classes de types, mais elles sont globalement couvertes une fois déclarées et elles ne peuvent pas être passées explicitement comme dans Scala. Plusieurs instances d'une classe de types pour un type donné sont résolues en encapsulant un newtype afin de lever les ambiguïtés, alors que dans Scala, cela serait résolu simplement en scoop ou en transmettant explicitement les instances.

Etant donné que Haskell n'est pas "orienté objet", il n'y a pas de dichotomie méthode / fonction. Chaque fonction est de première classe et chaque fonction est spécifiée par défaut (pas de Fonction1, Fonction2, etc.).

Haskell n’a pas de mécanisme de sous-type, mais les classes de type peuvent avoir une relation de sous-classe.

Answer 2

Je ne crois pas que quiconque ait systématiquement comparé Haskell (comme le montre le système de types de GHC) à Scalas. Les principaux points de différence sont le degré d'inférence de type et le support pour les types de rang supérieur. Mais un traitement complet des différences serait un résultat publiable.