Wie Variable als Scala-Typ-Parameter verwenden?

Question

Ich möchte so etwas wie die folgenden Funktionen ausführen:

val aoeu = List((0, 1), (0, 1, 2)) 
List(Tuple2, Tuple3).foreach { snth => 
    println(aoeu.filter(_.isInstanceOf[snth]).map(_.asInstanceOf[snth])) 
} 

Ist das möglich?

Answer 1

Wie schon erwähnt, ist es in Scala typensicher und (relativ) einfach, einen Typparameter zu übergeben und einen Wert zurück zu bekommen. Was schwierig und nicht kompilierfähig ist, geht in die andere Richtung. Zu Ihrer Frage, wie sie aussieht, ist die Antwort ... irgendwie. Wir können eine Typklasse definieren, um die Idee der sicheren Konvertierung zu erfassen, einige Instanzen für die Typen einrichten, an denen wir interessiert sind, und dann unsere Operationen ausführen. Also hier ist, was ich habe:

import scala.util.Try 

/** 
A typeclass to represent safe casting behaviour. 
*/ 
trait HasInstance[A] { def apply(any: Any): Option[A] } 

object HasInstance { 
    /** 
    A helper to quickly create a typeclass instance. 
    */ 
    private class Impl[A](_apply: Any => Option[A]) 
    extends HasInstance[A] { 
    override def apply(any: Any): Option[A] = _apply(any) 
    } 

    /* Instances for standard types. */ 

    implicit val int: HasInstance[Int] = 
    new Impl(any => Try(any.asInstanceOf[Int]).toOption) 

    implicit def tuple2[A, B]: HasInstance[Tuple2[A, B]] = 
    new Impl(any => Try(any.asInstanceOf[Tuple2[A, B]]).toOption) 

    implicit def tuple3[A, B, C]: HasInstance[Tuple3[A, B, C]] = 
    new Impl(any => Try(any.asInstanceOf[Tuple3[A, B, C]]).toOption) 
} 

object Test { 
    def test(): Unit = { 
    val xs = List((0, 1), (0, 1, 2)) 

    // Flatmap will automatically filter out `None` values. 

    println(xs flatMap implicitly[HasInstance[Tuple2[Int, Int]]].apply) 
    // ==> List((0, 1)) 

    println(
     xs flatMap implicitly[HasInstance[Tuple3[Int, Int, Int]]].apply) 
    // ==> List((0, 1, 2)) 
    } 
} 

Bitte beachte, dass wir noch keine Instanzen in einer Liste erfassen können, weil ihre Typen würden Scala zwingen upCast zu AnyRef sie zusammen zu speichern. Wenn Sie heterogene Listen haben und abbilden möchten, befinden Sie sich in Formlosem Gebiet. In der Tat, Sie könnten es trotzdem sein, weil Sie wahrscheinlich eine generische Ableitung durchführen möchten, um Instanzen für HasInstance einfach ableiten zu können.