Quel est le but de Rank2Types?

Il est difficile de comprendre de plus haut rang polymorphisme, à moins que vous étude Système De F directement, parce que Haskell est conçu pour cacher les détails de qui de vous, dans l'intérêt de la simplicité.

Mais, fondamentalement, l'idée est que les types polymorphes n'ont pas vraiment de la a -> b forme qu'ils n'en Haskell; en réalité, ils ressemblent à de ce, toujours de manière explicite les quantificateurs:

id :: ∀a.a → a
id = Λt.λx:t.x

Si vous ne connaissez pas le "∀" symbole, c'est de lire que "pour tous"; ∀x.dog(x) signifie "pour tout x, x est un chien." "Λ", c'est le capital lambda, utilisées pour le captage sur les paramètres de type; ce que la deuxième ligne indique que l'id est une fonction qui prend un type t, puis retourne une fonction qui est paramétrée par le type.

Vous voyez, dans le Système F, vous ne pouvez pas appliquer une fonction comme ça id à une valeur tout de suite; vous devez d'abord appliquer le Λ-fonction d'un type afin d'obtenir un λ-fonction que vous appliquez à une valeur. Ainsi, par exemple:

(Λt.λx:t.x) Int 5 = (λx:Int.x) 5
                  = 5

Standard Haskell (c'est à dire, Haskell 98 et 2010) simplifie pour vous en n'ayant aucun de ces types de quantificateurs, capitale des lambdas et les applications de type, mais en coulisses, le GHC met quand il analyse le programme pour la compilation. (C'est tout au moment de la compilation de trucs, je crois, avec pas de gestion d'exécution.)

Mais Haskell manipulation automatique, cela signifie qu'il suppose que "∀" n'apparaît jamais sur la gauche de la branche d'une fonction ("→") de type. Rank2Types et RankNTypes éteindre les restrictions et vous permettent de remplacer Haskell des règles par défaut pour l'endroit où insérer forall.

Pourquoi voudriez-vous faire cela? Parce que le plein, sans restriction de F est hella puissant, et il peut faire beaucoup de trucs cool. Par exemple, le type de la clandestinité et de la modularité peut être mis en œuvre à l'aide de rang supérieur à partir de types. Prenez par exemple un simple vieux de la fonction du rang suivant-1 de type (de la scène):

f :: ∀r.∀a.((a → r) → a → r) → r

À utiliser f, l'appelant doit d'abord choisir les types à utiliser pour r et a, puis fournir un argument de type résultant. Si vous pouviez choisir r = Int et a = String:

f Int String :: ((String → Int) → String → Int) → Int

Mais maintenant, comparez cela à la suite de plus haut rang type:

f' :: ∀r.(∀a.(a → r) → a → r) → r

Comment fonctionne une fonction de ce type de travail? Ainsi, pour l'utiliser, il faut d'abord spécifier le type à utiliser pour r. Dites-nous choisir Int:

f' Int :: (∀a.(a → Int) → a → Int) → Int

Mais maintenant, le ∀a est à l'intérieur de la fonction de flèche, de sorte que vous ne pouvez pas choisir ce type à utiliser pour a; vous devez appliquer f' Int pour un Λ-fonction du type approprié. Cela signifie que la mise en œuvre de f' obtient à choisir ce type à utiliser pour a, pas l'appelant de f'. Sans de plus haut rang types, au contraire, l'appelant choisit toujours les types.

Quoi est-ce utile pour? Eh bien, pour beaucoup de choses en fait, mais l'idée est que vous pouvez l'utiliser pour modéliser des choses comme la programmation orientée objet, où les "objets" bundle cachées des données en collaboration avec certaines méthodes de travail sur les données cachées. Ainsi, par exemple, un objet avec les deux méthodes, l'une qui renvoie un Int et un autre qui renvoie un String, pourraient être mises en œuvre avec ce type:

myObject :: ∀r.(∀a.(a → Int, a -> String) → a → r) → r

Comment cela fonctionne? L'objet est mis en œuvre comme une fonction qui a des données internes de type hidden a. En fait d'utiliser l'objet, à ses clients de passer dans un "rappel" de la fonction que l'objet d'appels avec les deux méthodes. Par exemple:

myObject String (Λa. λ(length, name):(a → Int, a → String). λobjData:a. name objData)

Nous voici, en gros, en invoquant l'objet de la deuxième méthode, celle dont le type est a → String pour un inconnu a. Eh bien, inconnu à myObjects clients; mais ces clients ne sais, à partir de la signature, qu'ils seront en mesure d'appliquer l'une des deux fonctions, une pour elle, et obtenir une Int ou un String.

Pour un Haskell exemple, ci-dessous le code que j'ai écrit quand j'ai appris moi-même RankNTypes. Il implémente un type appelé ShowBox qui rassemble une valeur d'un type hidden avec ses Show instance de classe. Notez que dans l'exemple en bas, je fais une liste de ShowBox dont le premier élément est fabriqué à partir d'un nombre, et le second à partir d'une chaîne. Depuis les types sont cachés à l'aide de la plus-rang types, ce n'est pas violer la vérification de type.

{ -# LANGUAGE RankNTypes #- }
{ -# LANGUAGE ImpredicativeTypes #- }

type ShowBox = forall b. (forall a. Show a => a -> b) -> b

mkShowBox :: Show a => a -> ShowBox
mkShowBox x = \k -> k x

-- | This is the key function for using a 'ShowBox'.  You pass in
-- a function @k@ that will be applied to the contents of the 
-- ShowBox.  But you don't pick the type of @k@'s argument--the 
-- ShowBox does.  However, it's restricted to picking a type that
-- implements @Show@, so you know that whatever type it picks, you
-- can use the 'show' function.
runShowBox :: forall b. (forall a. Show a => a -> b) -> ShowBox -> b
-- Expanded type:
--
--     runShowBox 
--         :: forall b. (forall a. Show a => a -> b) 
--                   -> (forall b. (forall a. Show a => a -> b) -> b)
--                   -> b
--
runShowBox k box = box k


example :: [ShowBox] 
-- example :: [ShowBox] expands to this:
--
--     example :: [forall b. (forall a. Show a => a -> b) -> b]
--
-- Without the annotation the compiler infers the following, which
-- breaks in the definition of 'result' below:
--
--     example :: forall b. [(forall a. Show a => a -> b) -> b]
--
example = [mkShowBox 5, mkShowBox "foo"]

result :: [String]
result = map (runShowBox show) example

PS: pour tout le monde la lecture de ce qui est demandé comment venir ExistentialTypes dans GHC utilise forall, je crois que la raison est parce que c'est à l'aide de ce genre de technique derrière les coulisses.

De plus haut rang types ne sont pas aussi exotique que les autres réponses ont fait. Le croire ou pas, de nombreux langages orientés objet (notamment Java et C#!) cette fonctionnalité. (Bien sûr, personne dans ces communautés, les connaît par l'effrayant nom à consonance "de haut rang types".)

L'exemple que je vais donner est un manuel de mise en œuvre du modèle Visiteur, que j'utilise tout le temps dans mon travail quotidien. Cette réponse n'est pas conçu comme une introduction au modèle visiteur; que la connaissance est facilement disponible d'ailleurs.

Dans cette fastueuse imaginaire application RH, nous souhaitons opérer sur les employés qui peuvent être à temps plein du personnel permanent ou temporaire des entrepreneurs. Mon préféré variante du modèle Visiteur (et en effet celui qui est pertinent pour la RankNTypes) parameterises du visiteur, le type de retour.

interface IEmployeeVisitor<T>
{
    T Visit(PermanentEmployee e);
    T Visit(Contractor c);
}

class XmlVisitor : IEmployeeVisitor<string> { /* ... */ }
class PaymentCalculator : IEmployeeVisitor<int> { /* ... */ }

Le point est que un certain nombre de visiteurs avec différents types de retour peuvent tous fonctionner sur les mêmes données. Cela signifie IEmployee doit exprimer aucune opinion quant à ce qui T devrait être.

interface IEmployee
{
    T Accept<T>(IEmployeeVisitor<T> v);
}
class PermanentEmployee : IEmployee
{
    //...
    public T Accept<T>(IEmployeeVisitor<T> v)
    {
        return v.Visit(this);
    }
}
class Contractor : IEmployee
{
    //...
    public T Accept<T>(IEmployeeVisitor<T> v)
    {
        return v.Visit(this);
    }
}

Je tiens à attirer votre attention sur les types. Observer que IEmployeeVisitor universellement quantifie son type de retour, alors que IEmployee quantifie l'intérieur de son Accept méthode - c'est-à-dire, à un rang plus élevé. La traduction de clunkily de C# à Haskell:

data IEmployeeVisitor r = IEmployeeVisitor {
    visitPermanent :: PermanentEmployee -> r,
    visitContractor :: Contractor -> r
}

newtype IEmployee = IEmployee {
    accept :: forall r. IEmployeeVisitor r -> r
}

Donc là vous l'avez. De plus haut rang types montrer en C# lorsque vous écrivez contenant des méthodes génériques.

Pour ceux qui sont familiers avec les langages orientés objets, un de plus haut grade de la fonction est simplement une fonction générique qui attend comme argument d'une autre fonction générique.

E. g. en caractères d'imprimerie, vous pourriez écrire:

type WithId<T> = T & { id: number }
type Identifier = <T>(obj: T) => WithId<T>
type Identify = <TObj>(obj: TObj, f: Identifier) => WithId<TObj>

Voir comment la fonction générique de type Identify exigences d'une fonction générique de type Identifier? Cela rend Identify un de plus haut grade de la fonction.