在没有继承层次结构的scala中编写通用代码

Question

I have few classes which do not derive from any superclass. They all have bunch of same methods defined. For example,

class A {
    def getMsgNum = 1
}

class B {
    def getMsgNum = 2
}

I would like to write a generic function that will return message num based on object function is called with. So something like,

def getMsgNum[T](t: T) = t.getMsgNum

I think that because of type erasure I cannot expect that to work but I was looking at view bound and context bound with ClassTag but that still does not work.

def getType[T: ClassTag](msg: T) = {
    msg.getMsgNum
}

I come from C++ background and I am trying to achieve something to the effect of template compilation for every type.

Thanks for your time!

Answer 1

I personally prefer adhoc polymorphism with TypeClass ( http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-part-12-type-classes.html ) pattern. I think it will be much more "true scala way" solution for this kind of problem. Also structural typing more expensive at runtime because it use reflection for field access.

  class A
  class B

  trait ToMsgNum[T] {
    def getMsgNum: Int
  }

  implicit object AToMsgNum extends ToMsgNum[A] {
    def getMsgNum = 1
  }

  implicit object BToMsgNum extends ToMsgNum[B] {
    def getMsgNum = 2
  }


  def getMsgNum[T: ToMsgNum](t: T) =
    implicitly[ToMsgNum[T]].getMsgNum

  println(getMsgNum(new A))
  println(getMsgNum(new B))

Answer 2

def getMsgNum[T](t: T)(implicit ev: T => { def getMsgNum: Int }) = t.getMsgNum

where { def getMsgNum: Int } is a structural type. From the documentation :

A structural type is a type of the form Parents { Decls } where Decls contains declarations of new members that do not override any member in Parents.

and

Structural types provide great flexibility because they avoid the need to define inheritance hierarchies a priori

Please note that the above solution uses an implicit reflective call to access the field of the structural type, a language feature that has to be explicitly enabled by adding the import

import scala.language.reflectiveCalls

Answer 3

This is not too different from Eugene's solution but I think it's a bit clearer:

// predefined classes you have no access to
class Foo { def someMethod = "foo" }
class Bar { def someMethod = "bar" }

there's no way in Scala other than reflection or structural types (which is reflection in disguise) to generically call someMethod on these types. The way this can be made to work though, is by defining adapter objects that know how to deal with each type individually, and you then make generic calls on those instead:

trait HasSomeMethod[T] { def someMethod(x: T): String }
object FooHasSomeMethod extends HasSomeMethod[Foo] { def someMethod(x: Foo) = x.someMethod }
object BarHasSomeMethod extends HasSomeMethod[Bar] { def someMethod(x: Bar) = x.someMethod }

now you can pass one of those adapter objects into the method that needs generic access to Foo#someMethod and Bar#someMethod :

def invokeSomeMethod[T](x: T)(adapter: HasSomeMethod[T]) =
  adapter.someMethod(x)

invokeSomeMethod(new Foo)(FooHasSomeMethod)  // returns "foo"
invokeSomeMethod(new Bar)(BarHasSomeMethod)  // returns "bar"

(we could have used a single parameter list here but later we'll nede 2 lists anyway)

however, this is obviously not as useful as we'd like as we have to pass in the adapter manually. Let's introduce implicits to make Scala automatically look up the right adapter object and pass that in to our generic but inheritance'less method:

implicit object FooHasSomeMethod extends HasSomeMethod[Foo] { ... }
implicit object BarHasSomeMethod extends HasSomeMethod[Bar] { ... }

def invokeSomeMethod[T](x: T)(implicit adapter: HasSomeMethod[T]) =
  adapter.someMethod(x)

now these work:

invokeSomeMethod(new Foo)  // returns "foo"
invokeSomeMethod(new Bar)  // returns "bar"

The above 2 calls get translated automatically to the longer calls in the previous version; Scala looks up suitable values for the implicit adapter parameter automatically from the implicit objects (and also val s and def s, to be precise) available in the "environment" of the call.

---

You can also define invokeSomeMethod like this, which is just syntactic sugar over the above definition:

def invokeSomeMethod[T: HasSomeMethod](x: T) =
  implicitly[HasSomeMethod[T]].someMethod(x)

or, since T: HasSomeMethod auto-generates a second parameter list implicit evidence$1: HasSomeMethod[T] , this also works:

def invokeSomeMethod[T: HasSomeMethod](x: T) =
  evidence$1.someMethod(x)

---

The above "pattern" is known as Type Classes . So for example the T: HasSomeMethod bit can be read as "some type T that belongs to the type class HasSomeMethod " (or "...has been made an instance of the type class HasSomeMethod ").

For more on Type Classes, see eg http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-part-12-type-classes.html .

---

You can also define the HasSomeMethod type class instance for classes that don't even have someMethod nor bear no other resemblance to Foo and Bar whatsoever, if needed:

implicit object IntHasSomeMethod extends HasSomeMethod[Int] {
  def someMethod(x: Int) = "this is an int: " + x
}

invokeSomeMethod(3)  // returns "this is an int: 3"

---

If you need to define an instance of that type class for many classes, you can have a helper (with a name that matches the type class, for niceness):

def HasSomeMethod[T](fn: T => String) = new HasSomeMethod[T] {
  def someMethod(x: T) = fn(x)
}

now you can define type class instances (adapters) very concisely:

implicit val FooHasSomeMethod = HasSomeMethod[Foo](_.someMethod)
implicit val BarHasSomeMethod = HasSomeMethod[Bar](_.someMethod)
implicit val IntHasSomeMethod = HasSomeMethod[Int]("this is an int: " + _)
implicit val PersonHasSomeMethod = HasSomeMethod[Person](_.name)
// etc

Answer 4

If you dont want to use structural type (reflection) and implicit, how about create Adaptor on top of it, so you own method getMsgNum will implement based on the Adaptor instead of already existing class.

class A {
  def getMsgNum = 1
}

class B {
  def getMsgNum = 2
}

class C {
  def getMsgNum = 3
}

trait Adaptor[T] {
  def getMsgNum: Int
}

class AdaptorA(t: A) extends Adaptor[A] {
  def getMsgNum = t.getMsgNum
}

class AdaptorB(t: B) extends Adaptor[B] {
  def getMsgNum = t.getMsgNum
}

class AdaptorC(t: C) extends Adaptor[C] {
  def getMsgNum = t.getMsgNum
}


def getMsgNum[T](t: Adaptor[T]) = t.getMsgNum

getMsgNum(new AdaptorA(new A))  //1
getMsgNum(new AdaptorB(new B))  //2
getMsgNum(new AdaptorC(new C))  //3