Inherit class with chaining functions - scala

Question

Lets say i have a class with chaining functions
class Vehicle {
protected var position: (Int, Int) = (0, 0)
def moveLeft(meters: Int): Vehicle = {
position = position._1 - meters -> position._2
this
}
def moveForward(meters: Int): Vehicle = {
position = position._1 -> (position._2 + meters)
this
}
}
so each method returns instance itself
Now i want to inherit Vehicle and add some method to new class
class Helicopter extends Vehicle {
protected var verticalDimension: Int = 0
def flyIntoTheSky(meters: Int): Helicopter = {
verticalDimension += meters
this
}
}
If i will create a new class instance and call any functions from parent, for example
new Helicopter().moveLeft(10).moveForward(20)
i will not be able to call new class method flyIntoTheSky because methods return type is Vehicle, and Vehicle does not know anything about methods of Helicopter.
2 obvious ways to solve it:
Either using asInstanceOf
new Helicopter()
.moveLeft(10)
.moveForward(20).asInstanceOf[Helocopter]
.flyIntoTheSky(10000)
either overriding each and avery parental method in new class
Both ways are not looking nice, i would prefer to leave all this type issues to Vehicle class and forget about it, so i found(as i hoped) the solution, rewriting methods like this
def moveLeft[T](meters: Int, vehicle: T = this): T = {
position = position._1 - meters -> position._2
this.asInstanceOf[T]
}
so i expected that return type will be taken from method's second parameter vehicle, which always equals to default value "this", and will return the value of current type. But unfortunately
new Helicopter().moveLeft(10)
still returns value of type Vehicle
res0: Vehicle = Helicopter#1de81c37
So the first question: why it doesn't work as i expected. And the second: is there are any beautiful way to solve this problem
Thank you
PS In google i found this solution in Java
https://www.andygibson.net/blog/article/implementing-chained-methods-in-subclasses/
, but i dont know java and can not translate it in scala

Answer 1

If the method always returns this you can give it return type this.type.
def moveLeft(meters: Int): this.type = {
position = position._1 - meters -> position._2
this
}

Answer 2

Addressing comment
strange, i cant get sense. If this.type refers to Helicopter why def
moveLeft[T](meters: Int, vehicle: T = this): T refers still to Vehicle
Note that this and this.type exist in two separate worlds, although this.type is "encroaching" on the value world as I will attempt to explain bellow. The former is a value whilst latter is a type, although a special kind of type. The type of expression this is not this.type, instead according to SLS:
The expression this... stands for the object being defined by the innermost
template or compound type enclosing the reference. If this is a
compound type, the type of this is that compound type. If it is a
template of a class or object definition with simple name 𝐶, the type
of this is the same as the type of 𝐶.this.
The innermost enclosing class of this in def moveLeft[T](meters: Int, vehicle: T = this): T is in fact Vehicle, therefore the static type of this is Vehicle.
Now consider type this.type:
this . type
| | |
value dot notation type
\ /
-------------------------------
|
value-dependent type
Notice the dot notation . which is used on a value, that is, if this was not a value then we would use # notation like so this#type. However it is indeed a value, which means type type depends on value this. Now, what value does it depend on? Well, no pun intended, it depends. Given the expression new Helicopter() it depends on the value (object) referred to by new Helicopter(), whilst given the expression new Car() it depends on the value referred to by expression new Car(). Important to understand here is that despite the fact that now this.type seems to be "changing" depending on a value, it is still a static type proper, meaning there is no runtime type-checking shenanigans.
I believe the source of confusion stems from the fact that we know, given new Helicopter(), in both cases, this refers to object of class Helicopter at runtime, however the key is to understand what static types can compiler determine, which in turn yields what members are invokable. In the case of this.type the compiler can determine the narrowest possible value-dependent singleton type uniquely inhabited by this very value.
As a side-note here is my attempt using shapeless lenses:
import shapeless._
case class Position(x: Double, y: Double, z: Double = 0)
sealed trait Vehicle
case class Car(p: Position) extends Vehicle
case class Plane(p: Position) extends Vehicle
object Vehicle {
implicit val carPosLens = lens[Car].p
implicit val planePosLens = lens[Plane].p
}
implicit class Move[T <: Vehicle](v: T) {
def moveX(d: Double)(implicit ev: Lens[T, Position]): T = ev.modify(v)(p => p.copy(x = p.x + d))
def moveY(d: Double)(implicit ev: Lens[T, Position]): T = ev.modify(v)(p => p.copy(y = p.y + d))
}
implicit class Fly[T <: Plane](v: T) {
def moveZ(d: Int)(implicit ev: Lens[T, Position]): T = ev.modify(v)(p => p.copy(z = p.z + d))
}
Plane(Position(0,0,0)).moveX(42).moveY(-3.142).moveZ(11)
Car(Position(0,0)).moveX(1)
which outputs
res0: Plane = Plane(Position(42.0,-3.142,11.0))
res1: Car = Car(Position(1.0,0.0,0.0))