Che cosa significa l'operatore `#` in Scala?

Vedo questo codice in questo blog: Programmazione a livello di tipo in Scala :

// define the abstract types and bounds
trait Recurse {
  type Next <: Recurse
  // this is the recursive function definition
  type X[R <: Recurse] <: Int
}
// implementation
trait RecurseA extends Recurse {
  type Next = RecurseA
  // this is the implementation
  type X[R <: Recurse] = R#X[R#Next]
}
object Recurse {
  // infinite loop
  type C = RecurseA#X[RecurseA]
}

C'è un operatore #nel codice R#X[R#Next]che non ho mai visto. Dal momento che è difficile cercarlo (ignorato dai motori di ricerca), chi può dirmi cosa significa?

Per spiegarlo, dobbiamo prima spiegare le classi nidificate in Scala. Considera questo semplice esempio:

class A {
  class B

  def f(b: B) = println("Got my B!")
}

Ora proviamo qualcosa con esso:

scala> val a1 = new A
a1: A = A@2fa8ecf4

scala> val a2 = new A
a2: A = A@4bed4c8

scala> a2.f(new a1.B)
<console>:11: error: type mismatch;
 found   : a1.B
 required: a2.B
              a2.f(new a1.B)
                   ^

Quando dichiari una classe all'interno di un'altra classe in Scala, stai dicendo che ogni istanza di quella classe ha una tale sottoclasse. In altre parole, non esiste una A.Bclasse, ma ci sono a1.Be a2.Bclassi e sono classi diverse , come ci dice il messaggio di errore sopra.

Se non lo capisci, cerca i tipi dipendenti dal percorso.

Ora, #ti consente di fare riferimento a tali classi nidificate senza limitarlo a una particolare istanza. In altre parole, non c'è A.B, ma c'è A#B, il che significa una Bclasse nidificata di qualsiasi istanza di A.

Possiamo vederlo al lavoro modificando il codice sopra:

class A {
  class B

  def f(b: B) = println("Got my B!")
  def g(b: A#B) = println("Got a B.")
}

E provandolo:

scala> val a1 = new A
a1: A = A@1497b7b1

scala> val a2 = new A
a2: A = A@2607c28c

scala> a2.f(new a1.B)
<console>:11: error: type mismatch;
 found   : a1.B
 required: a2.B
              a2.f(new a1.B)
                   ^

scala> a2.g(new a1.B)
Got a B.

È noto come proiezione del tipo e viene utilizzato per accedere ai membri del tipo.

scala> trait R {
     |   type A = Int
     | }
defined trait R

scala> val x = null.asInstanceOf[R#A]
x: Int = 0

Fondamentalmente, è un modo di fare riferimento a classi all'interno di altre classi.

http://jim-mcbeath.blogspot.com/2008/09/scala-syntax-primer.html (cerca "pound")

Ecco una risorsa per la ricerca di "operatori simbolici" (che sono in realtà metodi), ma non ho capito come sfuggire a "#" per cercare in scalex)

http://www.artima.com/pins1ed/book-index.html#indexanchor