Was bedeutet der Operator "#" in Scala?

Ich sehe diesen Code in diesem Blog: Typ-Level-Programmierung 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]
}

#Der Code enthält einen Operator, den R#X[R#Next]ich noch nie gesehen habe. Wer kann mir sagen, was es bedeutet, da es schwierig ist, es zu suchen (von Suchmaschinen ignoriert)?

Um es zu erklären, müssen wir zuerst verschachtelte Klassen in Scala erklären. Betrachten Sie dieses einfache Beispiel:

class A {
  class B

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

Versuchen wir jetzt etwas damit:

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)
                   ^

Wenn Sie eine Klasse in einer anderen Klasse in Scala deklarieren, sagen Sie, dass jede Instanz dieser Klasse eine solche Unterklasse hat. Mit anderen Worten, es gibt keine A.BKlasse, aber es gibt a1.Bund a2.BKlassen, und sie sind verschiedene Klassen, wie die Fehlermeldung oben sagt.

Wenn Sie das nicht verstanden haben, suchen Sie nach pfadabhängigen Typen.

Jetzt #können Sie auf solche verschachtelten Klassen verweisen, ohne sie auf eine bestimmte Instanz zu beschränken. Mit anderen Worten, es gibt keine A.B, aber es gibt A#Beine Bverschachtelte Klasse einer beliebigen Instanz von A.

Wir können dies in der Arbeit sehen, indem wir den obigen Code ändern:

class A {
  class B

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

Und probieren Sie es aus:

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.

Es wird als Typprojektion bezeichnet und für den Zugriff auf Typmitglieder verwendet.

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

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

Grundsätzlich ist es eine Möglichkeit, auf Klassen innerhalb anderer Klassen zu verweisen.

http://jim-mcbeath.blogspot.com/2008/09/scala-syntax-primer.html (Suche nach "Pfund")

Hier ist eine Ressource für die Suche nach "symbolischen Operatoren" (die wirklich Methoden sind), aber ich habe nicht herausgefunden, wie ich "#" entkommen kann, um in scalex zu suchen.)

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