self-type

This is a followup to this question . I'm trying to implement vectors in scala with a generic super class using self-types: trait Vec[V] { self:V => def /(d:Double):Vec[V] def dot(v:V):Double def norm:Double = math.sqrt(this dot this) def normalize = self / norm } Here's an implementation of a 3D vector: class Vec3(val x:Double, val y:Double, val z:Double) extends Vec[Vec3] { def /(d:Double) = new Vec3(x / d, y / d, z / d) def dot(v:Vec3) = x * v.x + y * v.y + z * v.z def cross(v:Vec3):Vec3 = { val (a, b, c) = (v.x, v.y, v.z) new Vec3(c * y - b * z, a * z - c * x, b * x - a * y) } def perpTo(v

Would there be any way in scala, to define a trait's self type to be a case class, as in "any case class"? I would like a self type to be able to use the .copy method of a case class, enforcing that its self type is some case class not a regular class. Structural types, I think, won't help, as they require a signature comprising specific arguments (I can probably not structural-type generically for any case class ). Please forgo the "if you need that you must be doing something wrong", as I've already moved on but my api design - will have been slicker if the above were possible. I am also

In Scala, I've seen the constructs trait T extends S and trait T { this: S => used to achieve similar things (namely that the abstract methods in S must be defined before an instance may be created). What's the difference between them? Why would you use one over the other? I'd use self-types for dependency-management: This trait requires another trait to be mixed in. And I'd use inheritance to refine another trait or interface. Just as an example: trait FooService trait FooRemoting { this : FooService => } trait FooPersistence { this : FooService => } object Services extends FooService with

I understand the use for explicitly typed self-references : trait T { self : T2 => ... } In the body, self is an alias for this but has the more precise type T with T2 . Now, I've seen this in code: trait T { self => ... } That is, an explicit self reference with no additional type information. In this configuration, is there any situation in which self is not just an alias for this ? It is an alias for this . Your first example is useful for ensuring that the trait has been mixed in to an appropriate type, and makes those methods available. The second example is useful when you have inner

I couldn't find the answer to this in any other question. Suppose that I have an abstract superclass Abstract0 with two subclasses, Concrete1 and Concrete1. I want to be able to define in Abstract0 something like def setOption(...): Self = {...} where Self would be the concrete subtype. This would allow chaining calls to setOption like this: val obj = new Concrete1.setOption(...).setOption(...) and still get Concrete1 as the inferred type of obj. What I don't want is to define this: abstract class Abstract0[T <: Abstract0[T]] because it makes it harder for clients to handle this type. I tried