Statische Importe innerhalb scala REPL

Question

das folgende Objekt Gegeben:

scala> object P2pClient { 
    | type Num = Double 
    | type Weights = Array[Array[Num]] 
    | } 
defined object P2pClient 

und die folgende Import:

import P2pClient._ 

Der Weights Typ scheint richtig zu verstehen:

val w: Weights = new Weights(3) 
w: P2pClient.Weights = Array(null, null, null) 

Aber warum ist es nicht arbeitet in dem folgende Konstrukt:

case class SendWeightsReq(W: Weights) extends P2pReq[Weights] { 
    | override def value() = W 
    | } 
<console>:12: error: not found: type Weights 
     case class SendWeightsReq(W: Weights) extends P2pReq[Weights] { 
                  ^
<console>:12: error: not found: type Weights 
     case class SendWeightsReq(W: Weights) extends P2pReq[Weights] { 
            ^

Alle Ideen, was hier geschieht (/ Abhilfe)?

Aktualisierung Es scheint erhebliche Einschränkungen bei Platzhalterimporten in der REPL zu geben. Hier ist eine andere einfachere Darstellung:

scala> import reflect.runtime.universe._ 
import reflect.runtime.universe._ 

scala> trait TT { def x[T <: java.io.Serializable : TypeTag]: T } 
<console>:10: error: not found: type TypeTag 
     trait TT { def x[T <: java.io.Serializable : TypeTag]: T } 
                ^

So sehen wir, dass die Wildcard-Import tat nicht Arbeit. Hier ist der gleiche Code mit dem expliziten Paket:

scala> trait TT { def x[T <: java.io.Serializable : reflect.runtime.universe.TypeTag]: T } 
defined trait TT 

Answer 1

Ich sehe das Problem ist aufgrund meiner Verwendung der Spark REPL spark-shell. Das Problem tritt nicht in der normalen Scala REPL auf.

Answer 2

Gute Nachrichten: Ihr Code funktioniert! Schlechte Nachrichten: Ich habe keine Ahnung, warum es nicht für dich funktioniert.

Hier ist meine REPL Sitzung; Ich wollte dein Beispiel aufbauen und sehen, was kaputt war, aber nichts.

scala> object P2pClient { type Num = Int; type Weights = Array[Array[Num]] } 
defined object P2pClient 

scala> import P2pClient._ 
import P2pClient._ 

scala> val x = new Weights(3) 
x: Array[Array[P2pClient.Num]] = Array(null, null, null) 

scala> case class SendWeights(W: Weights) 
defined class SendWeights 

scala> val s = new SendWeights(new Weights(3)) 
s: SendWeights = SendWeights([[I@1cab0bfb) 

Hmmm. Trivial Beispiel funktioniert.

scala> case class SendWeights2(w: Weights) { def dubs = w } 
defined class SendWeights2 

Funktioniert, wenn es einen Körper hat.

scala> trait P2pReq[+T] { def value(): Unit } 
defined trait P2pReq 

scala> case class SendWeights3(W: Weights) extends P2pReq[Weights] { 
override def value() = W } 
defined class SendWeights3 

scala> val foo = new SendWeights3(new Weights(3)) 
foo: SendWeights3 = SendWeights3([[I@51dcb805) 
res2: P2pClient.Weights = Array(null, null, null) 

arbeitet uuuuund, wenn es ein polymorphes Merkmal erweitert und überschreibt eines seiner Mitglieder. Das einzige, was vielleicht anders ist, ist Ihre Definition von P2pReq, aber ich sehe nicht, wie dies dazu führen kann, dass einer Ihrer Typen vom Interpreter nicht erkannt wird.