O que o operador `#` significa no Scala?

Vejo este código neste blog: Programação em nível de tipo no 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]
}

Existe um operador #no código R#X[R#Next]que eu nunca vi. Como é difícil pesquisá-lo (ignorado pelos mecanismos de pesquisa), quem pode me dizer o que isso significa?

Para explicar, primeiro precisamos explicar as classes aninhadas no Scala. Considere este exemplo simples:

class A {
  class B

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

Agora vamos tentar algo com isso:

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 você declara uma classe dentro de outra classe no Scala, está dizendo que cada instância dessa classe possui uma subclasse. Em outras palavras, não há nenhuma A.Bclasse, mas existem a1.Be a2.Baulas, e eles são diferentes classes, como a mensagem de erro está nos dizendo acima.

Se você não entendeu isso, procure os tipos dependentes do caminho.

Agora, #é possível consultar essas classes aninhadas sem restringi-las a uma instância específica. Em outras palavras, não existe A.B, mas existe A#B, o que significa uma Bclasse aninhada de qualquer instância de A.

Podemos ver isso no trabalho, alterando o código acima:

class A {
  class B

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

E experimentando:

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.

É conhecido como projeção de tipo e é usado para acessar os membros do tipo.

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

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

Basicamente, é uma maneira de se referir a classes dentro de outras classes.

http://jim-mcbeath.blogspot.com/2008/09/scala-syntax-primer.html (procure por "libra")

Aqui está um recurso para pesquisar "operadores simbólicos" (que são realmente métodos), mas ainda não descobri como escapar de "#" para pesquisar no scalex)

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