scala extend class with overloaded method - scala

Question

I am trying to extend class with overloaded method so I can instantiate it and pass different number of argument but keep common type of Foo and Bar. How can I make my code runnable?
class GenericClass {
def run(x: Int): Unit
def run(x: Int, y: Int): Unit
}
class Foo extends GenericClass {
def run(x: Int): Unit
}
class Bar extends GenericClass {
def run(x: Int, y: Int)
}
def getRun(hello: String) = {
hello match {
case "foo" => new Foo
case "bar" => new Bar
}
}
def execIt(runType: String) = {
case "foo" => getRun(runType).run(2)
case "bar" => getRun(runType).run(2, 3)
}
execIt("foo")

Answer 1

You can try to introduce a type member
trait GenericClass {
type In
def run(x: In): Unit
}
class Foo extends GenericClass {
override type In = Int
override def run(x: Int): Unit = println("Foo#run")
}
class Bar extends GenericClass {
override type In = (Int, Int)
override def run(x: (Int, Int)): Unit = println("Bar#run")
}
def getRun(hello: String) = {
hello match {
case "foo" => new Foo
case "bar" => new Bar
}
}
def execIt(runType: String) = getRun(runType) match {
case foo: Foo => foo.run(2)
case bar: Bar => bar.run(2, 3)
}
execIt("foo") // Foo#run
or a type class
trait GenericClass
class Foo extends GenericClass
class Bar extends GenericClass
trait Run[A <: GenericClass, T] {
def run(a: A, t: T): Unit
}
object Run {
implicit val foo: Run[Foo, Int] = (a, t) => println("Run.foo")
implicit val bar: Run[Bar, (Int, Int)] = (a, t) => println("Run.bar")
}
implicit class RunOps[A <: GenericClass](val a: A) extends AnyVal {
def run[T](t: T)(implicit r: Run[A, T]): Unit = r.run(a, t)
}
def getRun(hello: String) = {
hello match {
case "foo" => new Foo
case "bar" => new Bar
}
}
def execIt(runType: String) = getRun(runType) match {
case foo: Foo => foo.run(2)
case bar: Bar => bar.run(2, 3)
}
execIt("foo") // Run.foo
Please notice that I modified execIt as well.
Also you can keep everything as is and just throw NotImplementedError for methods that aren't needed
trait GenericClass {
def run(x: Int): Unit
def run(x: Int, y: Int): Unit
}
class Foo extends GenericClass {
def run(x: Int): Unit = println("Foo#run")
def run(x: Int, y: Int): Unit = ???
}
class Bar extends GenericClass {
def run(x: Int): Unit = ???
def run(x: Int, y: Int) = println("Bar#run")
}
def getRun(hello: String) = {
hello match {
case "foo" => new Foo
case "bar" => new Bar
}
}
def execIt(runType: String) = runType match {
case "foo" => getRun(runType).run(2)
case "bar" => getRun(runType).run(2, 3)
}
execIt("foo") // Foo#run
although this last option seems to abuse OOP.