Je suis presque sûr qu'ils ne sont pas les mêmes. Cependant, je suis embourbé dans la l'idée commune que "Rust ne supporte pas" les types de type plus élevé (HKT), mais offre au contraire polymorphisme paramétrique . J'ai essayé de m'y retrouver et de comprendre la différence entre les deux, mais je me suis de plus en plus empêtré.
D'après ce que j'ai compris, il y a sont Les types de type supérieur en Rust, au moins les bases. En utilisant l'annotation "*", un HKT a un type, comme par exemple * -> *
. Par exemple, Maybe
est de type * -> *
et pourrait être implémenté comme ceci en Haskell.
data Maybe a = Just a | Nothing
Ici,
-
Maybe
est un constructeur de type et doit être appliqué à un type concret pour devenir un type concret de type "*". -
Just a
yNothing
sont des constructeurs de données.
Dans les manuels sur Haskell, ce type est souvent utilisé comme exemple de type supérieur. Cependant, en Rust, il peut simplement être implémenté comme un enum, qui après tout est un type type de somme :
enum Maybe<T> {
Just(T),
Nothing,
}
Où est la différence ? D'après ce que j'ai compris, c'est un exemple parfait d'un type supérieur.
- Si en Haskell, ceci est utilisé comme un exemple de manuel de HKTs, pourquoi il est dit que Rust n'a pas de HKT ? Est-ce que le
Maybe
se qualifie comme un HKT ? - Faut-il plutôt dire que Rust n'a pas entièrement soutenir HKT ?
- Quelle est la différence fondamentale entre HKT et le polymorphisme paramétrique ?
Cette confusion continue quand on regarde les fonctions, je peux écrire une fonction paramétrique qui prend un Maybe
et, à ma connaissance, un HKT comme fonction. argument.
fn do_something<T>(input: Maybe<T>) {
// implementation
}
Encore une fois, en Haskell, ce serait quelque chose comme
do_something :: Maybe a -> ()
do_something :: Maybe a -> ()
do_something _ = ()
ce qui conduit à la quatrième question.
- Où s'arrête exactement le soutien aux types supérieurs ? Quel est l'exemple exemple minimal pour que le système de types de Rust ne puisse pas exprimer HKT ?
Questions connexes :
J'ai parcouru un grand nombre de questions liées au sujet (y compris les liens qu'ils ont vers des articles de blog, etc.) mais je n'ai pas pu trouver de réponse à mes questions principales (1 et 2).
- En Haskell, les "types supérieurs" sont-ils *vraiment* des types ? Ou bien désignent-ils simplement des collections de types *concrets* et rien de plus ?
- Structure générique sur un type générique sans paramètre de type
- Types plus élevés en Scala
- Quels types de problèmes le "polymorphisme de type supérieur" permet-il de mieux résoudre ?
- Types de données abstraits et polymorphisme paramétrique en Haskell
Mise à jour
Merci pour les nombreuses bonnes réponses qui sont toutes très détaillées et qui m'ont beaucoup aidé. J'ai décidé d'accepter la réponse d'Andreas Rossberg car son explication m'a le plus aidé à me mettre sur la bonne voie. En particulier la partie concernant la terminologie.
J'étais vraiment enfermé dans le cycle de la pensée que tout ce qui est du genre * -> * ... -> *
es supérieur . L'explication qui souligne la différence entre * -> * -> *
y (* -> *) -> *
était crucial pour moi.
8 votes
Je pense que ce que l'on veut dire par "Rust ne supporte pas les types de type supérieur" est qu'il ne peut pas abstrait sur elles, c'est-à-dire qu'on ne peut pas quantifier sur des variables de type de type
* -> *
ou plus.3 votes
Oui, ce que Rust n'a pas, c'est un polymorphisme de type supérieur. Comme d'habitude, les gens sont très négligents avec le langage de manière confuse.
0 votes
Je ne suis pas sûr de bien comprendre ce que vous dites tous les deux. Voulez-vous dire que, par exemple, un type générique
T
doit être un type concret et ne peut pas être lui-même un type supérieur ? Autrement dit, quelque chose commestruct Baz<T<V>> {}
ne fonctionnera pas ?4 votes
J'entends par "type supérieur" un constructeur de type qui prend des paramètres avec des types contenant
->
(de la même manière qu'une fonction d'ordre supérieur est une fonction qui prend des paramètres dont les types contiennent des éléments d'ordre supérieur).->
s). Par cette définitionMaybe
es no un type de type supérieur, puisque son seul argument est un type régulier de type*
.0 votes
@Benjamin Quelque chose comme une liste de Maybes, par exemple ?
2 votes
@StarSheriff Non, parce que
[]
est un autre constructeur de type régulier (son paramètre est également de type*
).Monad
est un exemple de classe de type supérieur, parce que sesm
a une sorte de* -> *
(Monad :: (* -> *) -> Constraint
).2 votes
HKT permettrait quelque chose comme
struct Baz<C<_>> { C<A> a; C<B> b; }
-- Notez que le paramètre C n'est pas un type, mais quelque chose qui fait correspondre des types à des types. Scala dispose de HKT (si vous les activez), et Haskell en dispose également.0 votes
Ver reddit.com/r/rust/comments/2av5tv/