ricerca di parole chiave `type` e` # in scala

Question

Qualcuno potrebbe spiegare come la parola chiave type e l'operatore # funzionano in scala e come usarlo? Si prega di guardare gli esempi.

//Example1 
scala> type t1 = Option.type 
defined type alias t1 

//Shouldn't this work since previous example simply works? 
scala> type t2 = String.type 
<console>:7: error: type mismatch; 
found : String.type 
required: AnyRef 
     type t2 = String.type 
     ^

//lets define custom trait T 
scala> trait T 
defined trait T 

//... and obtain it's type like in Example1. 
//Shouldn't this work since previous Example1 simply works? 
scala> type t3 = T.type 
<console>:7: error: not found: value T 
     type t3 = T.type 
     ^

//Lets define some value of type T 
scala> val v4 = new T{} 
v4: T = $anon$1@5c3e8c76 

//and obtain it's type (works) 
scala> type t4 = v4.type 
defined type alias t4 

//this doesn't work 
scala> type t4_1 = (new T{}).type 
<console>:1: error: identifier expected but 'new' found. 
     type t4_1 = (new T{}).type 

//as well as this (doesn't work) 
scala> type t5 = "abc".type 
<console>:1: error: identifier expected but string literal found. 
     type t5 = "abc".type 
     ^

//but this compiles well 
scala> val v6 = "abc" 
v6: String = abc 

scala> type t6 = v6.type 
defined type alias t6 


//lets create some values of created types: 
scala> type t1 = Option.type 
defined type alias t1 

scala> val v1_1 = Some(10) 
v1_1: Some[Int] = Some(10) 

scala> type t7 = v1_1.type 
defined type alias t7 

scala> val v7:t7 = null 
v7: t7 = null 

scala> val v7_1:t7 = v1_1 
v7_1: t7 = Some(10) 

scala> val v7_2:t7 = Some(10) 
<console>:9: error: type mismatch; 
found : Some[Int] 
required: t7 
    (which expands to) v1_1.type 
     val v7_2:t7 = Some(10) 
      ^


//next let's try # operator 

scala> class X[A,B](a:A,b:B) 
defined class X 

//doesn't work 
scala> type xa = X[A,B]#A 
<console>:8: error: not found: type A 
     type xa = X[A,B]#A 
     ^
<console>:8: error: not found: type B 
     type xa = X[A,B]#A 
      ^

//but such approach works: 
scala> trait X2[C]{ 
    type A 
    type B 
    val c:C 
} 
defined trait X2 

scala> type xa2_1 = X2[String]#A 
defined type alias xa2_1 

scala> type xa2_2[M] = X2[M]#A 
defined type alias xa2_2 

Answer 1

In primo luogo, le vostre domande su type:

Il lato destro di una dichiarazione di tipo deve essere il nome di un tipo con un percorso stabile. Quindi prendere il vostro esempi uno per uno:

type t1 = Option.type 

t1 è un alias per il tipo di oggetto Option, non la classe Option.

type t2 = String.type 

Questo è un errore perché non c'è String oggetto. L'errore è un po 'strano perché String è una classe Java e quindi opera sotto regole diverse (poiché le classi Java non hanno mai compagni).

type t3 = T.type 

idem. Questa volta l'errore più chiaro, perché T è una classe Scala e quindi il compilatore può senza ambiguità dire "T non nomina un oggetto con un tipo di"

type t4 = v4.type 

Questo è il tipo Singleton dell'oggetto nominato dal val v4 . Non fa riferimento a nessuna istanza di tipo T, né a nessuna istanza della classe anonima creata dall'espressione new T{}. Si riferisce a un tipo che è solo rappresentato da v4 e null, vale a dire che sono gli unici valori consentiti di quel tipo.

type t4_1 = (new T{}).type 

Questo è illegale perché la cosa si sta prendendo il tipo di deve essere un identificatore stabile (grosso modo, un identificatore cui referant non può cambiare - se il percorso completo del idenfier è costituito da solo i nomi di pacchetti, object s, e val s, è stabile).

type t5 = "abc".type 

Idem.

type t6 = v6.type 

v6 è un identificatore stabile. t6 è il tipo abitato esclusivamente da quella particolare istanza di String a cui si fa riferimento con il nome v6 (e null).

type v6 = v1_1.type 

Ancora, un tipo singleton.

val v7: t7 = null 

null è un valore valido di tipo t7

val v7_1:t7 = v1_1 

Così è questo particolare oggetto.

val v7_2:t7 = Some(10) 

Ma questo è un diverso oggetto (anche se è == di v7, non eq ad essa) e quindi non è un membro di questo tipo.

Ora circa #:

class X[A,B](a:A,b:B) 

A e B sono parametri di tipo. Non possono essere riferiti al di fuori della classe. Puoi considerarli come alias di tipo astratto con visibilità private[this], anche se non è abbastanza preciso.

type xa = X[A,B]#A 

Quindi sì, non visibile.

type xa2_1 = X2[String]#A 

Da questo A si riferisce ad un tipo pubblico alias, può essere indicato dal nome esterno alla classe. Nota che questo caso particolare è piuttosto inutile, perché non sai assolutamente nulla di questo tipo. se il vostro tratto X2 aveva un metodo che ha restituito valori di tipo A, si potrebbe fare qualcosa di simile

val aFromX2: xa2_1 = x2instance.methodThatReturnsAnA 

..ma allora non si poteva fare altro con esso, anche passare di nuovo a un'istanza di X2[String] perché non c'è garanzia che i due A si riferiscano allo stesso tipo! D'altra parte, se si dispone di un'istanza concreta, si potrebbe fare questo:

def passAroundA(x2instance: X2[String]) { 
    type x2a = x2instance.A // note dot, not # 
    val a: x2a = x2instance.methodThatReturnsAnA 
    x2instance.methodThatTakesAnA(a) 
} 

In questo caso funziona perché, anche se non abbiamo idea di cosa A è in realtà, sappiamo che i due metodi di utilizzare il stesso tipo - qualsiasi cosa sia stata fissata nella costruzione di .

Answer 2

Praticamente tutto ciò che riguarda la tua domanda è spiegato in this imho absolutely essential talk su casi d'uso come il modello di corrispondenza, ecc. Ti suggerisco di prendere il tempo per guardarlo e lo sforzo per fare qualcosa al riguardo. Un sacco di materiale relativo al sistema Scala Tipo era in realtà una magia per me fino a quando ho visto questo video. Potrei risparmiare un sacco dei miei giorni uomo cercando di risolvere il comportamento strano del sistema di tipi e di tipo inferenza se ero a conoscenza di queste cose.