Quel est le but des descriptions de type dans Scala?

Il n’y a pas beaucoup d’informations dans la spécification sur le type de description, et il n’y a certainement rien là-dedans sur le but. A part “faire passer le travail de varargs”, à quoi devrais-je utiliser type ascription? Vous trouverez ci-dessous une version de Scala REPL pour la syntaxe et les effets de son utilisation.

scala> val s = "Dave" s: java.lang.Ssortingng = Dave scala> val p = s:Object p: java.lang.Object = Dave scala> p.length :7: error: value length is not a member of java.lang.Object p.length ^ scala> p.getClass res10: java.lang.Class[_  s.getClass res11: java.lang.Class[_  p.asInstanceOf[Ssortingng].length res9: Int = 4 

L’atsortingbution de type indique simplement au compilateur quel type vous attendez d’une expression, parmi tous les types valides possibles.

Un type est valide s’il respecte les contraintes existantes, telles que les déclarations de variance et de type, et il s’agit de l’un des types que l’expression à laquelle il s’applique ” est un ” ou d’une conversion qui s’applique dans la scope.

Ainsi, java.lang.Ssortingng extends java.lang.Object , donc toute Ssortingng est aussi un Object . Dans votre exemple, vous avez déclaré que vous souhaitez que l’expression s soit traitée comme un Object et non une Ssortingng . Comme il n’y a pas de contraintes empêchant cela et que le type désiré est l’un des types s est a , cela fonctionne.

Maintenant, pourquoi voudriez-vous cela? Considère ceci:

 scala> val s = "Dave" s: java.lang.Ssortingng = Dave scala> val p = s: Object p: java.lang.Object = Dave scala> val ss = scala.collection.mutable.Set(s) ss: scala.collection.mutable.Set[java.lang.Ssortingng] = Set(Dave) scala> val ps = scala.collection.mutable.Set(p) ps: scala.collection.mutable.Set[java.lang.Object] = Set(Dave) scala> ss += Nil :7: error: type mismatch; found : scala.collection.immutable.Nil.type (with underlying type object Nil) required: java.lang.Ssortingng ss += Nil ^ scala> ps += Nil res3: ps.type = Set(List(), Dave) 

Vous pourriez également avoir résolu ce Set[AnyRef] déclaration de type s at ss ou en déclarant que le type de ss est Set[AnyRef] .

Cependant, les déclarations de type n’obtiennent la même chose que tant que vous atsortingbuez une valeur à un identifiant. Ce que l’on peut toujours faire, bien sûr, si l’on ne se soucie pas de jeter le code avec des identifiants uniques. Par exemple, ce qui suit ne comstack pas:

 def prefixesOf(s: Ssortingng) = s.foldLeft(Nil) { case (head :: tail, char) => (head + char) :: head :: tail case (lst, char) => char.toSsortingng :: lst } 

Mais cela fait:

 def prefixesOf(s: Ssortingng) = s.foldLeft(Nil: List[Ssortingng]) { case (head :: tail, char) => (head + char) :: head :: tail case (lst, char) => char.toSsortingng :: lst } 

Il serait idiot d’utiliser un identifiant ici à la place de Nil . Et bien que je puisse simplement écrire List[Ssortingng]() , ce n’est pas toujours une option. Considérez ceci, par exemple:

 def firstVowel(s: Ssortingng) = s.foldLeft(None: Option[Char]) { case (None, char) => if ("aeiou" contains char.toLower) Some(char) else None case (vowel, _) => vowel } 

Pour la référence, voici ce que Scala 2.7 spec (projet de 15 mars 2009) a à dire à propos de l’atsortingbution de type:

 Expr1 ::= ... | PostfixExpr Ascription Ascription ::= ':' InfixType | ':' Annotation {Annotation} | ':' '_' '*' 

Une possibilité est lorsque le niveau de protocole réseau et série, puis ceci:

 val x = 2 : Byte 

est beaucoup plus propre que

 val x = 2.asInstanceOf[Byte] 

La seconde forme est également une conversion à l’exécution (non gérée par le compilateur) et pourrait mener à des conditions de dépassement / débordement intéressantes.

J’utilise l’atsortingbution de type au papier sur les trous dans l’inférence de type de Scala. Par exemple, foldLeft sur une collection de type A prend un élément initial de type B et une fonction (B, A) => B utilisée pour replier les éléments de la collection dans l’élément initial. La valeur réelle du type B est déduite du type de l’élément initial. Puisque Nil étend List [Nothing], son utilisation comme élément initial pose problème:

 scala> val x = List(1,2,3,4) x: List[Int] = List(1, 2, 3, 4) scala> x.foldLeft(Nil)( (acc,elem) => elem::acc) :9: error: type mismatch; found : List[Int] required: scala.collection.immutable.Nil.type x.foldLeft(Nil)( (acc,elem) => elem::acc) ^ scala> x.foldLeft(Nil:List[Int])( (acc,elem) => elem::acc ) res2: List[Int] = List(4, 3, 2, 1) 

Alternativement, vous pouvez simplement utiliser List.empty [Int] au lieu de Nil: List [Int].

 scala> x.foldLeft(List.empty[Int])( (acc,elem) => elem::acc ) res3: List[Int] = List(4, 3, 2, 1) 

edit: List.empty [A] est implémenté comme

 override def empty[A]: List[A] = Nil 

(la source)

C’est en fait une forme plus verbeuse de Nil: List [A]

Vous pouvez trouver ce fil illuminer, si un peu compliqué à suivre. La chose importante à noter est que vous ajoutez des astuces de contrainte au vérificateur de types – cela vous donne un peu plus de contrôle sur ce que fait cette phase de compilation.

Type Inférence: Nous pouvons ignorer le nom explicite de type de quelque chose dans le code source, appelé Type Inference (bien que requirejs dans certains cas exceptionnels).

Type Ascription: Être explicite à propos du type de quelque chose s’appelle un Type Ascription. Quelle différence cela peut-il faire?

ex: val x = 2: Byte

voir aussi: 1. Nous pouvons explicitement donner le type de retour à nos fonctions

 def t1 : Option[Option[Ssortingng]] = Some(None) > t1: Option[Option[Ssortingng]] 

Une autre façon de déclarer cela pourrait être:

 def t2 = Some(None: Option[Ssortingng]) > t2: Some[Option[Ssortingng]] 

Ici, nous n’avons pas Option[Option[Ssortingng]] explicitement le type de retour Option[Option[Ssortingng]] et Comstackr en a déduit Some[Option[Ssortingng]] . Why Some[Option[Ssortingng]] est parce que nous avons utilisé la description de type dans la définition.

  1. Une autre façon d’utiliser la même définition est la suivante:

    def t3 = Some(None)

    > t3: Some[None.type]

Cette fois, nous n’avons rien dit explicitement au compilateur (ni ce defi). Et cela a déduit notre définition de Certains [Aucun.type]