Uma maneira que temfoi sugerido lidar com definições duplas de métodos sobrecarregados é substituir a sobrecarga pela correspondência de padrões:

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

Essa abordagem exige que entregemos a verificação de tipo estático nos argumentos parafoo. Seria muito melhor poder escrever

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

Posso me aproximarEither, mas fica feio rapidamente com mais de dois tipos:

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

Parece que uma solução geral (elegante, eficiente) exigiria definiçãoEither3, Either4, .... Alguém sabe de uma solução alternativa para alcançar o mesmo fim? Que eu saiba, Scala não possui "disjunção de tipo" embutida. Além disso, as conversões implícitas definidas acima estão à espreita na biblioteca padrão em algum lugar para que eu possa importá-las?