Method generalization in Scala

Question

I tried to generalize a method to provide a type safe API as follows:

abstract class AbstractCommand {
  type T = this.type
  def shuffler(s: T => Seq[AbstractCommand])
}

class TestCommand extends AbstractCommand {
  override def shuffler(s: (TestCommand) => Seq[AbstractCommand]): Unit = ??? //error
}

I wanted the expected type of the function argument to be the most specific in this hierarchy. But it didn't work.

Is there a way to do something like that in Scala without introducing some helper type parameters?

@dk14 I thought that as well but I believe St.Antario wants to avoid type parameters. — stefanobaghino, Jul 06 '17 at 10:03
@stefanobaghino as a compromise, you could use type members instead (but still will have to manually assign them in derived class) — dk14, Jul 06 '17 at 10:05

Yuval Itzchakov · Accepted Answer · 2017-07-06T11:27:23.297

4

This looks like a perfect use-case for F-Bounded Polymorphism:

abstract class AbstractCommand[T <: AbstractCommand[T]] {
  self: T =>
  def shuffler(s: T => Seq[AbstractCommand[T]])
}

class TestCommand extends AbstractCommand[TestCommand] {
  override def shuffler(s: (TestCommand) => Seq[AbstractCommand[TestCommand]]): Unit = ???
}

And with a type member instead of a type parameter (using the example provided by Attempting to model F-bounded polymorphism as a type member in Scala):

abstract class AbstractCommand { self =>
  type T >: self.type <: AbstractCommand
}

class TestCommand extends AbstractCommand {
  type T = TestCommand
}

class OtherCommand extends AbstractCommand {
  type T = OtherCommand
}

edited Jul 06 '17 at 11:27

answered Jul 06 '17 at 11:08

Yuval Itzchakov

146,575
32
257
321

Agree, already understood. But I think you forget `self: T =>` in an abstract class. – St.Antario Jul 06 '17 at 11:09
@St.Antario Definitely. Didn't see you guys already talked about this in the comment of the other answer :X – Yuval Itzchakov Jul 06 '17 at 11:11
Btw. Don't you know if it's possible to implement F-bounded polymorphism with type members? Not generic types. – St.Antario Jul 06 '17 at 11:16
You mean with type members instead of type parameters? – Yuval Itzchakov Jul 06 '17 at 11:19
Exactly/. I tried to declare `type T <: AbstractCommand{ type T <: T }`. but it didn't compile. – St.Antario Jul 06 '17 at 11:19
`Error:(5, 35) cyclic aliasing or subtyping involving type T type T <: AbstractCommand{ type T <: T }` – St.Antario Jul 06 '17 at 11:20
And one more questions :). Why did you declare `def instance`? I tried without it and it also worked. I mean if we override E with a wrong type it does not compile. – St.Antario Jul 06 '17 at 11:26
@St.Antario No need for it here. Removed :) – Yuval Itzchakov Jul 06 '17 at 11:27
1

Thanks much. Understood. – St.Antario Jul 06 '17 at 11:28

score 2 · Answer 2 · answered Jul 06 '17 at 10:08

You could avoid defining T in the abstract class :

abstract class AbstractCommand {
  type T
  def shuffler(s: T => Seq[AbstractCommand])
}

class TestCommand extends AbstractCommand {
  type T = TestCommand
  override def shuffler(s: (TestCommand) => Seq[AbstractCommand]): Unit = ??? //compiles !
}

On the downside, it's a bit more verbose, on the upside, it's even more generic !

score 2 · Answer 3 · answered Jul 06 '17 at 10:08

2

I'm not entirely sure it fits your need, but I've been able to compile and run the following, let me know if it helps:

abstract class AbstractCommand {
  def shuffler(s: this.type => Seq[AbstractCommand])
}

class TestCommand extends AbstractCommand {
  override def shuffler(s: (TestCommand.this.type) => Seq[AbstractCommand]): Unit = {
    s(this)
    println("success")
  }
}

new TestCommand().shuffler(_ => Seq.empty) // prints "success"

answered Jul 06 '17 at 10:08

stefanobaghino

11,253
4
35
63

The thing is I want the only most specific type to be accepted – St.Antario Jul 06 '17 at 10:38
From what I can get, `TestCommand` is the most specific type (as it's a specialization of `AbstractCommand`) and only that gets accepted for that particular implementation; can you perhaps show me an example to clarify your remark? Maybe use a gist or something like that. – stefanobaghino Jul 06 '17 at 10:43
Actually, yes. F-bound polymorphism is a solution – St.Antario Jul 06 '17 at 10:55
Ok, but just to come clear, this is not F-Bounded Polymorphism, which requires a type parameter. You can find more about it here: https://twitter.github.io/scala_school/advanced-types.html#fbounded – stefanobaghino Jul 06 '17 at 10:57
@stefanobaghino I am not sure if you know and simply don't mention this in the answer, but `this.type` here is a lot more specific than `TestCommand`. If you try the signature author wants (`def shuffler(s: TestCommand => Seq[AbstractCommand]): Unit`) it won't compile, unless I miscounted variances. – Alexey Romanov Jul 06 '17 at 19:56

Method generalization in Scala

3 Answers3