nasıl

Question

bir genel işlevi dikkate derleme zamanında olmayan genel tür uygulamak?

var actorReceive: Receive = PartialFunction.empty 
def addCase[T](handler: T => Boolean): Unit = { 
    actorReceive = actorReceive orElse ({ 
     case msg: T => // call handle at some point, plus some other logic 
      handler(msg) 
    }) 
} 

addCase fonksiyonu gibi ClassTag isteyerek çözülebilir tip silme uyarısı, neden olacaktır:

---

ben çözmek istiyorum ast sorun böyle bir şeydir def addCase[T: ClassTag](..., ama yine de ClassTag

addCase[List[Int]](_ => {println("Int"); true}) 
addCase[List[String]](_ => {println("String"); false}) 

actorReceive(List("str")) // will print "Int" 

yukarıdaki kodyazdırır: gibi aramalar karşı korumak olamazherhangi bir uyarı veya hata vermeden, herhangi bir çıkış yolu var mı? aşağıdaki gibi

Answer 1

Bunu tür sistemde olduğu gibi yansıma olmadan da uygulamak için bir yolu yoktur.

Bunu yapmanın en iyi yolu, bir türün çalışma zamanında silinecek türde bir parametresi olmadığını gösteren NonEraseable[A] gibi bir tür sınıfına sahip olmaktır. Kapsam içinde bir örtülü NonEraseable[A], A'un hiçbir tür parametresi içermediği anlamına gelmelidir.

import scala.language.experimental.macros 
import scala.reflect.macros.blackbox.Context 

trait NonEraseable[A] 

object NonEraseable { 

    implicit def ev[A]: NonEraseable[A] = macro evImpl[A] 

    def evImpl[A](c: Context)(implicit tt: c.WeakTypeTag[A]): c.Expr[NonEraseable[A]] = { 
     import c.universe._ 
     val tpe = weakTypeOf[A] 
     if(tpe.dealias.typeArgs.isEmpty) 
      c.Expr[NonEraseable[A]](q"new NonEraseable[$tpe] {}") 
     else 
      c.abort(c.enclosingPosition, s"$tpe contains parameters that will be erased at runtime.") 
    } 

} 

Kullanım örneği: Bu kullanma

def onlySimple[A : NonEraseable](value: A): Unit = println(value) 

scala> onlySimple(1) 
1 

scala> onlySimple(List(1, 2, 3)) 
<console>:13: error: List[Int] contains parameters that will be erased at runtime. 
     onlySimple(List(1, 2, 3)) 
       ^

, derleme anında bir tür parametresi de zorlayabilir bunlar görünce el işi yapabilir örtük bir makro oluşturmak için sıkıcı olurdu Bağlantılı NonEraseable olan A, istediğiniz türde türüdür. (Hile yapmadığınızı varsayar ve tür sınıfının örneğini el ile oluşturduğunuz varsayılır)

Answer 2

En az çalışma zamanında başarısız olmasına alabilirsiniz:

def addCase[T: ClassTag](handler: T => Boolean): Unit = 
    if (classTag[T].runtimeClass.getTypeParameters.nonEmpty) { 
    // throw an exception 
    } else { 
    // the main code 
    } 

Derleme zamanı hatası (, denenmemiş yaklaşık) bir işlevi yerine bir macro kullanılarak elde edilebilir:

def addCase[T](handler: T => Boolean): Unit = macro addCaseImpl 

def addCaseImpl[T: c.WeakTypeTag](c: Context)(handler: c.Expr[T => Boolean]): c.Expr[Unit] = 
    if (c.weakTypeOf[T].typeParams.nonEmpty) { 
    c.abort(c.enclosingPosition, "Generic types not allowed in addCase") 
    } else { 
    // generate code for main line 
    }