重用Scala类型作为方法定义中的界限

Question

Is it possible to write something like this and reuse the HelperTest.AnyHelper type?

class HelperUtil 
{    
/* this is what I would like to write... reuse the AnyHelper type in the definition */
   def accept[HelperTest.AnyHelper](helper : HelperTest.AnyHelper) = 
   {
       // code here
   }
}

object HelperTest 
{
    type AnyHelper = T forSome { type T <: GenericHelper }
}

abstract class GenericHelper 
{
    val name = ""
}

Currently I am forced to write this, since the compiler won't let me:

class HelperUtil 
{
/* gets too verbose, if the generic type gets more complex and would be useful to reuse the type */
    def accept[T <: GenericHelper](helper : T) = 
    {
        // code here
    }
}

abstract class GenericHelper 
{
    val name = ""
}

Or am I completely on the wrong track?

Answer 1

I guess you are mistaken about how type parameters in a signature such as def accept[T] work. The type variable T in this signature gets bound , that is, T is introduced as a new type variable. If there already exists a type variable with the same name in the current context, then it will be shadowed by the newly bound T . Consider this example:

class Foo[T] {
  def id[T](t: T) = t
}

The class signature binds a new T that can be referred to in the class body. However, the method signature binds a T as well, which shadows the class T . With the result, that you can instantiate the class T with some type X and the method T with some other type Y :

val f = new Foo[String]
f.id(0)

Back to your code. Your signature

def accept[HelperTest.AnyHelper](helper : HelperTest.AnyHelper)

thus tries to bind a new type variable HelperTest.AnyHelper - which the compiler rejects, because type variables may not contain a dot ( . ).

Do the following instead:

import scala.language.existentials

trait A
class B1 extends A
class C1 extends B1
class B2 extends A

object HelperUtil {
  type MyA = T forSome { type T <: A }
}

class HelperUtil {
   /* Reuse type declaration */
   def foo(a: HelperUtil.MyA) = println(a.getClass.getName)
   def bar(a: HelperUtil.MyA) = println(a.getClass.getName)
   def baz(a: HelperUtil.MyA) = println(a.getClass.getName)
}

val hu = new HelperUtil

/* Instantiate with different types */
hu.foo(new B1) // B1
hu.foo(new B2) // B2
hu.bar(new C1) // C1