Type de T forSome {type T}

Question

Je passe par drmacvier blog sur les types existentiels dans Scala. Après l'avoir lu, j'expérimentais avec les types et je vérifie l'égalité des types de la manière suivante, comme indiqué dans le blog rnduja.

def implicitly[A](implicit a: A) = a 

// To check equality of two types 
class =:=[A, B] 
implicit def equalTypeInstance[A] = new =:=[A, A] 
def type_==[A, B](implicit ev: A =:= B = null) = ev != null 

// To check subtype relation between two types 
class <:<[-A, +B] 
implicit def subTypeInstance[A] = new <:<[A, A] 
def type_<[A, B](implicit ev: A <:< B = null) = ev != null 

La première que j'ai vérifié était cette chose:

type_==[Any, T forSome{type T}] // true 

ce que je ne pouvais pas comprendre est T forSome{type T} est satisfaite par tout type mais pourquoi est son type Any. En supposant, puisque Any est un ancêtre commun de tous les types possibles, il est logique qu'ils soient égaux. De la même manière, j'étais capable de raisonner.

type_==[Array[Any], Array[T forSome{type T}]] // true 
type_==[List[Any], List[T forSome{type T}]] // true 

Je n'ai pas réussi à obtenir ce droit avec le même raisonnement.

type_==[Array[Any], (Array[T] forSome{type T})] // false 
type_==[List[Any], (List[T] forSome{type T})] // true 

Que manque-t-il ici? Est-ce que mon raisonnement est défectueux?

Answer 1

ce que je ne pouvais pas comprendre est T forsome {type T} est satisfaite par tout type mais pourquoi est son type Tous

Toute valeur (aucun type) a un certain type (au moins tapez Any). Donc, il a le type T pour certains types T. Mais cela signifie qu'il a également le type T forSome { type T }. Donc, toute valeur de type Any a le type T forSome { type T } (et vice versa).

Pour les deux premières comparaisons: si A est égal à B, alors F[A] doit être égale à F[B], quelle que soit F est. Vous venez de vérifier que Any et T forSome {type T} sont égaux, donc ... Mais vous ne pouvez tout simplement pas utiliser le même raisonnement pour les deux autres cas: que serait A, B et F?

Array[Any] n'est pas la même chose que Array[T] forSome { type T }, parce que disons que vous avez une valeur

val array: Array[String] = Array("a") 

Ensuite, il est de type Array[T] forSome { type T } (comprenez-vous pourquoi?):

val arrayForSome: Array[T] forSome { type T } = array // compiles 

mais

val arrayOfAny: Array[Any] = array 

ne compile pas (parce que Array est invariant). Donc clairement Array[T] forSome { type T } et Array[Any] sont différents: une valeur peut avoir un de ces types sans avoir l'autre.