Scala可以约束对象图,以便只显示与上下文相关的那些对象吗？

DCI认为你经常有一个相当复杂的对象图,但在任何一个用例中你通常只想使用一个子图.你有一个有棒和蝙蝠的Foo,但是当你处于用例1时,你只关心Bar,而在使用案例2时,只关注蝙蝠.

例如,假设你有这种结构,并且Role1用例需要Foo-> Bar-> Baz-> Bin和Role2用例需要Foo-> Bat-> Baz-> Buz ：

class Foo{
   val bar = new Bar() //Only relevant to Role 1
   val bat = new Bat() //Only relevant to Role 2 
}

class Bar {
   val baz = new Baz() 
}

class Bat {
   val baz = new Baz()
}

//Relevant to both Role 1 and 2 (via Bar or Bat)
class Baz {
  val bin = new Bin() //Only relevant to Role 1
  val buz = new Buz() //Only relevant to Role 2
}

class Bin{}
class Buz{}

通过使用特征,很容易看出如何限制单个类中的访问：

trait FooInRole1 { def bar : Bar }  //Define accessor in trait
s/Foo/Foo extends FooInRole1/       //Change Foo's declaration to implement trait
val f : FooInRole1 = new Foo        //LHS is i'face,RHS is implementation
//f.bat <--Compile error              Irrelevant field is not available. o/

但是,您必须为与用例相关的每个对象重复此模式. (例如,你需要一个BazInRole1来访问bin而一个BazInRole2来访问biz)

我的问题是,是否有一些方法可以避免编写所有这些容易出错的,名称空间拥挤的特征.例如,我可以想象像这样的代码(不编译)：

class Foo[T] {
  T match { 
    case r1 : Role1 => def bar : Bar[T]
    case r2 : Role2 => def bat : Bat[T]
    case _ => //Nothing
  }
}

val fInRole1 = new Foo[Role1] //Provides Foo->Bar->Baz->Bin
val fInRole2 = new Foo[Role2] //Provides Foo->Bat->Baz->Buz

似乎Scala的类型系统足以表达这样的事情,但我无法弄明白.