Expliquer les classes de type dans HASKELLL

Une classe de type peut être comparée au concept de «mise en œuvre» d'une interface. Si certains types de données in Haskell implémentent l'interface "show", il peut être utilisé avec toutes les fonctions qui s'attendent à un objet "Afficher".

Eh bien, la version courte est la suivante: Type Classes est ce que Haskell utilise pour le polymorphisme ad-hoc. strong>

... mais cela n'a probablement rien clarifié pour vous. P>

Le polymorphisme devrait être un concept familier aux personnes provenant d'un antécédents d'OUP. Le point clé ici est toutefois la différence entre paramétric em> et polymorphisme ad-hoc em>. P>

polymorphisme paramétrique strong> signifie des fonctions qui fonctionnent sur un type structurel qui lui-même est paramétré par d'autres types, tels qu'une liste de valeurs. Le polymorphisme paramétrique est à peu près la norme partout dans Haskell; C # et Java appellent-le "génériques" strong>. Fondamentalement, une fonction générique fait la même chose à une structure spécifique, quel que soit les paramètres de type. P>

polymorphisme ad-hoc fort>, d'autre part, signifie une collection de fonctions distinctes, faire différents em> (mais conceptuellement associés) en fonction des types. Contrairement au polymorphisme paramétrique, les fonctions polymorphes ad-hoc doivent être spécifiées individuellement pour chaque type possible qu'ils peuvent être utilisés. Le polymorphisme ad hoc est donc un terme généralisé pour une variété de fonctions trouvées dans d'autres langues, telles que la surcharge de fonction dans le polymorphisme de l'expédition C / C ++ ou à base de classe dans OOP. strong> P>

Un important point de vente de classes de type Haskell sur d'autres formes de polymorphisme ad hoc est une plus grande flexibilité en raison de permettant à polymorphisme n'importe où dans la signature de type forte>. Par exemple, la plupart des langues ne distinguent pas les fonctions surchargées en fonction du type de retour; Les classes de type peuvent. p>

Les interfaces disponibles dans de nombreuses langues de l'OOP sont quelque peu similaires aux classes de type Haskell - vous spécifiez un groupe de noms de fonction / signatures que vous souhaitez traiter de manière polymorphe ad hoc, puis Décrivez explicitement comment différents types peuvent être utilisés avec ces fonctions. Les classes de type Haskell sont utilisées de la même manière, mais avec une plus grande flexibilité: vous pouvez écrire des signatures de type arbitraire pour les fonctions de classe de type, avec la variable de type utilisée pour la sélection d'instance apparaissant n'importe où em> vous aimez, non seulement comme le Type d'un objet em> que des méthodes sont appelées. P>

Certains compilateurs HASKELLL - y compris les extensions de langue les plus populaires, GHC - offrent des classes de type encore plus puissantes, telles que Les classes de type multi-paramètres EM>, qui vous permettent de faire une répartition de la fonction polymorphe ad-hoc sur la base de plusieurs types (similaires à ce que l'appelé "multiple expédition" em> dans OOP). P>

interface IApplicative<>
{
    IApplicative<T> Pure<T>(T item);
    IApplicative<U> Map<T, U>(Function<T, U> mapFunc, IApplicative<T> source);
    IApplicative<U> Apply<T, U>(IApplicative<Function<T, U>> apFunc, IApplicative<T> source);
}

interface IReducible<>
{
    U Reduce<T,U>(Function<T, U, U> reduceFunc, U seed, IReducible<T> source);
}

En plus de ce que XTOFL et CAMCCANN ont déjà écrit dans leurs excellentes réponses, une chose utile à constater lors de la comparaison des interfaces de Java avec les classes de type Haskell, c'est le suivant:

1. Les interfaces Java sont fermées , ce qui signifie que l'ensemble des interfaces d'interfaces à tout outil de classe donnée est décidé une fois et pour tous quand et où il est défini;

2. Les classes de type Haskell sont ouvertures , ce qui signifie que tout type (ou groupe de types de classes de type multi-paramètres) peut être membre de n'importe quelle classe de type à tout moment, aussi longtemps Comme des définitions appropriées peuvent être fournies pour les fonctions définies par la classe de type.

   Cette ouverture de classes de type (et protocoles de Clojure, qui sont très similaires) est une propriété très utile; Il est tout à fait d'habitude qu'un programmeur Haskell propose une nouvelle abstraction et l'applique immédiatement à une gamme de problèmes impliquant des types préexistants grâce à une utilisation intelligente des classes de type.

en C ++ / etc, "Méthodes virtuelles" sont expédiées en fonction du type de Ceci / auto argument implicite. (La méthode est indiquée dans une table de fonction que l'objet pointe implicitement à) les classes de type

fonctionnent différemment et peuvent faire tout ce qui "interface" peut et plus encore. Commençons par un exemple simple de quelque chose que les interfaces ne peuvent pas faire: Haskell's lire classe de type. xxx

lisez > Le type de 'code est (lire a) => chaîne -> A , ce qui signifie pour chaque type qui implémente le lecture classe de type, lisez Peut convertir une chaîne sur ce type. C'est une expédition basée sur le type de retour, impossible avec "interfaces".

Ceci ne peut pas être effectué dans l'approche de C ++ et al, où la table de fonction est extraite de l'objet - ici, vous ne le faites pas même avoir l'objet pertinent jusqu'à après lire le renvoie alors comment pouvez-vous l'appeler?

une différence de mise en œuvre clé à partir d'interfaces qui permettent que cela se produise, est que la table des fonctions n'est pas pointé vers l'intérieur de l'objet, il est passé séparément par le compilateur sur les fonctions appelées.

En outre, en C ++ / etc. Lorsque l'on définit une classe, ils sont également responsables de la mise en œuvre de leurs interfaces. Cela signifie que vous ne pouvez pas simplement inventer une nouvelle interface et faire int ou std :: vecteur implémenter.

in haskell vous pouvez, et Ce n'est pas par "patching de singe" comme dans Ruby. Haskell a un bon schéma d'espacement de nom qui signifie que deux classes de type peuvent avoir une fonction du même nom et qu'un type peut toujours mettre en œuvre les deux.

Ceci permet à HASKELL d'avoir de nombreuses classes simples comme EQ (types qui prennent en charge la vérification de l'égalité), Afficher (types pouvant être imprimés sur une chaîne ), lire (Types qui peut être analysé à partir d'une chaîne ), monoïde (types qui ont une opération de concaténation et un élément vide) et de beaucoup d'autres, et permettent même aux types primitifs comme Int pour implémenter les classes de type appropriées.

avec la richesse des classes de type, les gens ont tendance à programmer à des types plus généraux, puis ont des fonctions plus réutilisables et car elles ont également moins de liberté lorsque Les types sont généraux, ils peuvent même produire moins de bugs!

TLDR: classes de type == génial