Wie verwendet man Typinformationen aus dem Mustervergleich?

Question

Ich habe folgendes Setup:

trait TypeA { override def toString() = "A" } 
trait TypeB { override def toString() = "B" } 
trait TypeC { override def toString() = "C" } 

def foo[T](t: T) = println(t) 

nun etwas tun Ich kann:

val valueB: Any = new TypeB {} 

val typedValue = valueB match { 
    case t: TypeA => foo(t) 
    case t: TypeB => foo(t) 
    case t: TypeC => foo(t) 
} 
// prints "B" 

Wenn ich dieses Pattern-Matching-Block verallgemeinern wollen, habe ich einfach tun können:

val typedValue = valueB match { 
    case t => foo(t) 
} 

und es wird funktionieren. In meinem realen Anwendungsfall muss ich die Typinformationen beim Aufruf der Methode explizit angeben, da es kein Funktionsargument gibt, aus dem sie abgeleitet werden könnte. Also wenn foo() war eine generische Methode mit Parameter T parameterisiert, aber ohne tatsächliche Parameter dieses Typs aus zu folgern, kann ich dies in ein Muster mit nur einer Case-Anweisung verallgemeinern (wahrscheinlich mit der Reflection API)?

Also, wie verallgemeinern?

val typedValue = valueB match { 
    case t: TypeA => foo[TypeA]() 
    case t: TypeB => foo[TypeB]() 
    case t: TypeC => foo[TypeC]() 
    ... 
} 

Answer 1

Wenn ich dieses Pattern-Matching-Block verallgemeinern wollen, kann ich einfach tun:

val typedValue = valueB match { 
    case t => foo(t) 
} 

In der Regel können Sie nicht. Z.B. wenn foo(x: TypeA), foo(x: TypeB) und foo(x: TypeC) sind separate Überlastungen. Und das ist die Situation für Ihren echten Code: Sie müssten separate Methoden für JsObject usw. schreiben, weil diese value Anrufe zufällig denselben Namen haben; Sie können foo(x: JsValue) oder foo[T <: JsValue](x: T) nicht schreiben, die tun würden, was Sie wollen (ohne die gleiche Übereinstimmung, die Sie vermeiden möchten).

In dem Fall, dass Sie eine einzelne polymorphe Methode tun haben: weil generische Argumente gelöscht erhalten, wenn Sie def foo[T]() = ..., haben foo[TypeA](), foo[TypeB]() und foo[TypeC]() den gleichen tatsächlichen Code ausführen (dies gilt nicht für classOf, isInstanceOf oder asInstanceOf , aber das sind die einzigen Ausnahmen und es ist, weil sie nicht wirklich generische Methoden sind). Sie können also einfach foo[<type-of-valueB>] anrufen. Damit sie unterschiedlich sind, muss foo ein implizites Argument haben, das von T abhängt, z.

trait Baz[A] { ... } 
object Baz { 
    implicit val bazTypeA: Baz[TypeA] = ... 
    ... 
} 

def foo[A]()(implicit baz: Baz[A]) = ... 

In diesem Fall wird die Art und Weise Verzweigung für das Verfahren zu vermeiden, ist foo Aufruf der gleichen impliziten zu akzeptieren:

def bar[A](value: A)(implicit baz: Baz[A]) = foo[A]() 

bar(new TypeA) // uses bazTypeA