两个耦合的Scala泛型类型构造函数如何相互引用类型参数？

Question

在Java 1.6.0_21中，下面的第一个例子编译得很好，我认为这是因为参数类型边界是空的。也就是说，在下面的“Z extends Zen”范围内，Java允许将Zen作为非原始类型的原始名称（相当于运行时“删除” 类型）。这可能是错误的，坏的，但它也可能是有用的，或坐大巴回家至少古怪 美好的时光：

public class CorefTest { 

    public static interface Tao<Z extends Zen> { 
    } 

    public static interface Zen<T extends Tao> { 
    } 
} 

在斯卡拉2.8.0.final，下面通过CleanOceanWithFish编译伟大了，显示 一些基本类型参​​数连接。但是当我们认识到Zen和Tao是相互依赖的泛型类型时，Scala编译器会拒绝我的编织结构。查看注释中的编译器错误。

package heaven.piece 
class Lucky { 
    trait Water {} 
    trait CleanWater extends Water {} 
    trait Sea [W <: Water] {} 
    trait Fish[S <: Sea[CleanWater]] {} 

    trait CleanOceanWithFish[F <: Fish[CleanOceanWithFish[F]]] 
        extends Sea[CleanWater]{} 

// Above code compiles fine, but the type constructor pair below doesn't compile 

    trait Tao[Z <: Zen[Tao[Z]]]{}; 

    trait Zen[T <: Tao[Zen[T]]]{}; 
} 
// error: type arguments [Lucky.this.Tao[Z]] do not conform to trait Zen's 
//  type parameter bounds [T <: Lucky.this.Tao[Lucky.this.Zen[T]]] 

// error: type arguments [Lucky.this.Zen[T]] do not conform to trait Tao's 
//  type parameter bounds [Z <: Lucky.this.Zen[Lucky.this.Tao[Z]]] 

那么，怎样才能正确地我绑斯卡拉（2.8.0）结道与禅之间？我真正想要的是使用Scala来扩展一些真正的Java类型，我使用上面的形式（通过“forSome”和“[_]”存在的类型并不能帮助你我到目前为止）。我认为在Scala中编译Zen和Tao 可能会显示出Java扩展的方式。如果你可以在你的答案中考虑Java扩展问题，那么更好。谢谢你的帮助！从尼基塔S.和克里斯N.很有帮助前两个回答以下问题，

我经验学到了一些更多关于各种Java +斯卡拉的共参照情景后

更新公布。其结果是，当我们想在互操作coreferent类型都的Java和Scala，那么这个Java结构：

public static interface JavaFunTao<JFZ extends JavaFunZen<? extends JavaFunTao<JFZ>>> { 
    public JFZ consider(JFZ someZen, JavaFunTao<JFZ> otherTao); 
} 
public static interface JavaFunZen<JFT extends JavaFunTao<? extends JavaFunZen<JFT>>> { 
    public JFT meditate(JFT someTao, JavaFunZen<JFT> otherZen); 
} 

提供在顶部更具体的打字比我的第一个Java例子（避免原始类型），并且是然后在斯卡拉正确扩展如下：

class HiFunTao[HFZ <: HiFunZen[ _ <: HiFunTao [HFZ]]] extends JavaFunTao[ HFZ] { 
    override def consider(someZen: HFZ, otherTao: JavaFunTao[HFZ]) : HFZ = { 
     println (this.toString() + " is considering " + someZen + " and " + otherTao); 
     someZen 
    } 
} 
class HiFunZen[HFT <: HiFunTao[ _ <: HiFunZen [HFT]]] extends JavaFunZen[ HFT] { 
    override def meditate(someTao: HFT, otherZen: JavaFunZen[HFT]) : HFT = { 
     println (this.toString() + " is meditating on " + someTao + " and " + otherZen); 
     someTao 
    } 
} 

我证实，我们可以根据这些简单的具体类型，实例化它们，并调用它们的方法。 Java和Scala中的关键步骤是将有界通配符放在类型参数树循环回当前声明类型的位置，即java中的“？extends”和Scala中的“_ <：”。

Answer 1

因为无论是禅，也不是道协，还有在禅和道一个可替代性的问题。这在2.8.1编译为我好：

trait Tao[+Z <: Zen[Tao[Z]]] 

trait Zen[+T <: Tao[Zen[T]]] 

当然，如果你想在z或T打坐那么这也不会为你工作，至少不完全是因为这个问题的声明在逆变位置具有协变类型参数。让您可以像这样的问题：

trait Tao[+Z <: Zen[Tao[Z]]] { 
    def meditate[M >: Z](m: M) =() 
} 

trait Zen[+T <: Tao[Zen[T]]] { 
    def meditate[M >: T](m: M) =() 
} 

但这仍可能产生，你可能不希望在你执行的因素。至少这是令人困惑的。 :)

更新：

这也，顺便说一下，避免NSkvortsov的答案的更新中提到的问题。这编译罚款：

class Zazen extends Zen[Tao[Zazen]] 

Answer 2

我想，这是你所需要的：

class MyClass { 

    trait Tao[Z <: Zen[_]]{}; 
    trait Zen[T <: Tao[_]]{}; 

} 

这个片段成功斯卡拉2.8.1

更新编译

不幸的是，在斯卡拉扩展CorefTest.Zen和CorefTest.Tao是不可能的。这是为什么。

以实现的Java接口的唯一方法是使用原始类型：

public class TaoImpl<Z extends CorefTest.Zen> implements CorefTest.Tao<Z> { } 

public class ZenImpl<T extends CorefTest.Tao> implements CorefTest.Zen<T> { } 

不是一个可以实例化这样的类：

TaoImpl<ZenImpl> tao = new TaoImpl<ZenImpl>(); 
ZenImpl<TaoImpl> zen = new ZenImpl<TaoImpl>(); 

但斯卡拉做不支持原始类型。所以TaoImpl和ZenImpl就是不能定义的。 请参阅本e-mail thread和问题#2091和#1737进行详细讨论