Wie definiere ich "Typdisjunktion" (Unionstypen)?
uf eine Weise, die @ hwurde vorgeschlagen mit doppelten Definitionen überladener Methoden umzugehen, bedeutet, das Überladen durch einen Mustervergleich zu ersetzen:
object Bar {
def foo(xs: Any*) = xs foreach {
case _:String => println("str")
case _:Int => println("int")
case _ => throw new UglyRuntimeException()
}
}
Dieser Ansatz erfordert, dass wir die statische Typprüfung der Argumente an @ übergebefoo
. Es wäre viel schöner, @ schreiben zu könn
object Bar {
def foo(xs: (String or Int)*) = xs foreach {
case _: String => println("str")
case _: Int => println("int")
}
}
Ich kann mit @ nahe kommEither
, aber es wird hässlich schnell mit mehr als zwei Arten:
type or[L,R] = Either[L,R]
implicit def l2Or[L,R](l: L): L or R = Left(l)
implicit def r2Or[L,R](r: R): L or R = Right(r)
object Bar {
def foo(xs: (String or Int)*) = xs foreach {
case Left(l) => println("str")
case Right(r) => println("int")
}
}
Es sieht so aus, als ob eine allgemeine (elegante, effiziente) Lösung die Definition von @ erfordern würdEither3
, Either4
, .... Kennt jemand eine alternative Lösung, um das gleiche Ziel zu erreichen? Meines Wissens hat Scala keine eingebaute "Typ-Disjunktion". Lauern die oben definierten impliziten Konvertierungen auch in der Standardbibliothek, sodass ich sie einfach importieren kann?