Dav*_*ave 377 scala traits self-type
特质的自我类型A:
trait B
trait A { this: B => }
说" A不能混合成一个不会扩展的具体类B".
另一方面,以下内容:
trait B
trait A extends B
说"混合的任何(混凝土或抽象)类A也将在B中混合".
这两个陈述不是同一个意思吗？自我类型似乎只是为了创建一个简单的编译时错误的可能性.
我错过了什么？
Dan*_*ral 264
它主要用于依赖注入,例如Cake Pattern.在Scala中存在一篇很好的文章,涵盖了许多不同形式的依赖注入,包括Cake Pattern.如果您使用Google"Cake Pattern and Scala",您将获得许多链接,包括演示文稿和视频.目前,这是另一个问题的链接.
现在,关于自我类型和扩展特征之间的区别是什么,这很简单.如果你说B extends A,那B 是一个A.当你使用自我类型时,B 需要一个A.使用自我类型创建了两个特定要求:
B延长,那么你需要混合一个A.A.请考虑以下示例:
scala> trait User { def name: String }
defined trait User
scala> trait Tweeter {
| user: User =>
| def tweet(msg: String) = println(s"$name: $msg")
| }
defined trait Tweeter
scala> trait Wrong extends Tweeter {
| def noCanDo = name
| }
<console>:9: error: illegal inheritance;
self-type Wrong does not conform to Tweeter's selftype Tweeter with User
trait Wrong extends Tweeter {
^
<console>:10: error: not found: value name
def noCanDo = name
^
如果Tweeter是子类User,则不会有错误.在上面的代码中,我们需要一个User无论何时Tweeter使用,然而User并没有提供Wrong,所以我们得到了一个错误.现在,上面的代码仍在范围内,请考虑:
scala> trait DummyUser extends User {
| override def name: String = "foo"
| }
defined trait DummyUser
scala> trait Right extends Tweeter with User {
| val canDo = name
| }
defined trait Right
scala> trait RightAgain extends Tweeter with DummyUser {
| val canDo = name
| }
defined trait RightAgain
因此Right,满足混合的要求User.但是,上述第二个要求并不令人满意:实施的负担User仍然存在于延伸的类别/特征中Right.
有了RightAgain这两个要求得到满足.提供了A User和实现User.
有关更多实际用例,请参阅本答案开头的链接!但是,希望现在你明白了.
Mus*_*med 153
自我类型允许您定义循环依赖项.例如,您可以实现此目的:
trait A { self: B => }
trait B { self: A => }
继承使用extends不允许这样做.尝试:
trait A extends B
trait B extends A
error: illegal cyclic reference involving trait A
在Odersky的书中,请参阅第33.5节(创建电子表格UI章节),其中提到:
在电子表格示例中,类Model继承自Evaluator,因此可以访问其评估方法.换句话说,类Evaluator将其自身类型定义为Model,如下所示:
package org.stairwaybook.scells
trait Evaluator { this: Model => ...
希望这可以帮助.
Dav*_*ith 56
另一个区别是自我类型可以指定非类型.例如
trait Foo{
this: { def close:Unit} =>
...
}
这里的自我类型是结构类型.结果是,在Foo中混合的任何东西都必须实现一个无法"关闭"的方法返回单元.这允许安全混合用于鸭子打字.
lcn*_*lcn 13
第2.3节"自我类型注释"Martin Odersky的原始Scala论文可伸缩组件抽象实际上解释了selftype超出mixin组合的目的:提供一种将类与抽象类型相关联的替代方法.
本文给出的例子如下,它似乎没有一个优雅的子类通讯员:
abstract class Graph {
type Node <: BaseNode;
class BaseNode {
self: Node =>
def connectWith(n: Node): Edge =
new Edge(self, n);
}
class Edge(from: Node, to: Node) {
def source() = from;
def target() = to;
}
}
class LabeledGraph extends Graph {
class Node(label: String) extends BaseNode {
def getLabel: String = label;
def self: Node = this;
}
}
Bru*_*eth 12
另一件事没有提到:因为自我类型不是所需类的层次结构的一部分,所以它们可以从模式匹配中排除,特别是当您与密封的层次结构进行详尽匹配时.当您想要建模正交行为时,这很方便,例如:
sealed trait Person
trait Student extends Person
trait Teacher extends Person
trait Adult { this : Person => } // orthogonal to its condition
val p : Person = new Student {}
p match {
case s : Student => println("a student")
case t : Teacher => println("a teacher")
} // that's it we're exhaustive
jaz*_*mit 10
TL; DR摘要其他答案:
您扩展的类型是暴露给继承的类型,但自我类型不是
例如:class Cow { this: FourStomachs }允许您使用仅适用于反刍动物的方法,例如digestGrass.然而,扩展Cow的特征将没有这样的特权.另一方面,class Cow extends FourStomachs会暴露digestGrass给任何人extends Cow .
自我类型允许循环依赖,而不扩展其他类型
让我们从周期性依赖开始吧.
trait A {
selfA: B =>
def fa: Int }
trait B {
selfB: A =>
def fb: String }
但是,此解决方案的模块化并不像它首次出现的那么大,因为您可以覆盖自我类型:
trait A1 extends A {
selfA1: B =>
override def fb = "B's String" }
trait B1 extends B {
selfB1: A =>
override def fa = "A's String" }
val myObj = new A1 with B1
但是,如果覆盖自身类型的成员,则会失去对原始成员的访问权限,但仍可通过超级继承访问该成员.那么使用继承真正获得的是:
trait AB {
def fa: String
def fb: String }
trait A1 extends AB
{ override def fa = "A's String" }
trait B1 extends AB
{ override def fb = "B's String" }
val myObj = new A1 with B1
现在我无法理解蛋糕模式的所有微妙之处,但令我印象深刻的是,强制模块化的主要方法是通过组合而不是继承或自我类型.
继承版本较短,但我更喜欢继承而不是自我类型的主要原因是我发现使用自我类型使初始化顺序正确更加棘手.但是,您可以使用继承无法执行的自我类型.自我类型可以使用类型,而继承需要特征或类,如:
trait Outer
{ type T1 }
trait S1
{ selfS1: Outer#T1 => } //Not possible with inheritance.
你甚至可以这样做:
trait TypeBuster
{ this: Int with String => }
虽然你永远无法实例化它.我没有看到任何绝对的理由不能从类型继承,但我当然觉得有路径构造函数类和特性是有用的,因为我们有类型构造函数traits/classes.不幸的是
trait InnerA extends Outer#Inner //Doesn't compile
我们有这个:
trait Outer
{ trait Inner }
trait OuterA extends Outer
{ trait InnerA extends Inner }
trait OuterB extends Outer
{ trait InnerB extends Inner }
trait OuterFinal extends OuterA with OuterB
{ val myV = new InnerA with InnerB }
或这个:
trait Outer
{ trait Inner }
trait InnerA
{this: Outer#Inner =>}
trait InnerB
{this: Outer#Inner =>}
trait OuterFinal extends Outer
{ val myVal = new InnerA with InnerB with Inner }
应该更加强调的一点是,特征可以扩展类.感谢David Maclver指出这一点.这是我自己的代码中的一个例子:
class ScnBase extends Frame
abstract class ScnVista[GT <: GeomBase[_ <: TypesD]](geomRI: GT) extends ScnBase with DescripHolder[GT] )
{ val geomR = geomRI }
trait EditScn[GT <: GeomBase[_ <: ScenTypes]] extends ScnVista[GT]
trait ScnVistaCyl[GT <: GeomBase[_ <: ScenTypes]] extends ScnVista[GT]
ScnBase继承自Swing Frame类,因此它可以用作自我类型,然后在最后混合(在实例化时).但是,val geomR需要在继承特征之前对其进行初始化.所以我们需要一个类来强制执行先前的初始化geomR.ScnVista然后可以通过多个正交特征继承该类,这些特征本身可以从中继承.使用多种类型参数(泛型)提供了另一种模块化形式.
trait A { def x = 1 }
trait B extends A { override def x = super.x * 5 }
trait C1 extends B { override def x = 2 }
trait C2 extends A { this: B => override def x = 2}
// 1.
println((new C1 with B).x) // 2
println((new C2 with B).x) // 10
// 2.
trait X {
type SomeA <: A
trait Inner1 { this: SomeA => } // compiles ok
trait Inner2 extends SomeA {} // doesn't compile
}