Çift kişilik tanımları ile başa çıkmak için been suggested fazla yüklenmiş yöntem olan tek yönlü desen eşleştirme ile aşırı yükleme yerine taşıyor

object Bar {
   def foo(xs: Any*) = xs foreach { 
      case _:String => println("str")
      case _:Int => println("int")
      case _ => throw new UglyRuntimeException()
   }
}

Bu yaklaşım foo bağımsız statik tür denetlemesi teslimiyet gerektirir. Daha güzel yazmak mümkün olacaktır

object Bar {
   def foo(xs: (String or Int)*) = xs foreach {
      case _: String => println("str")
      case _: Int => println("int")
   }
}

Either ile yaklaşabilirim ama çirkin hızlı ikiden fazla türleri ile alır:

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")
   }
}

Genel () zarif, verimli bir çözüm*12, Either4, ..*.tanımlanması gerekir gibi görünüyor. Herkes aynı sona ulaşmak için alternatif bir çözüm biliyor mu? Yerleşik olmayan Scala bilgime göre, "tür çözüm". Ayrıca, örtülü dönüşüm yukarıda tanımlanan alıyorum, böylece standart kütüphanede bir yerde pusuya yatmış durumda?

Miles Sabin çok güzel son blog görevinden Unboxed union types in Scala via the Curry-Howard isomorphism birleşim türü almak için bir yol açıklar:

O ilk tip olarak yazılabilir tanımlar

type ¬[A] = A => Nothing

De Morgan kullanarak bu onun Birliği türlerini tanımlamak Kanun

type ∨[T, U] = ¬[¬[T] with ¬[U]]

Aşağıdaki yardımcı yapıları ile

type ¬¬[A] = ¬[¬[A]]
type |∨|[T, U] = { type λ[X] = ¬¬[X] <:< (T ∨ U) }

aşağıdaki gibi sendika türleri yazabilirsiniz

def size[T : (Int |∨| String)#λ](t : T) = t match {
    case i : Int => i
    case s : String => s.length
}