Come faccio a impostare più di tipo ORed limiti a Scala

Question

è possibile fare qualcosa di simile in Scala:

class MyTest { 
    def foo[A <: String _or_ A <: Int](p:List[A]) = {} 
} 

Cioè, il tipo A potrebbe essere un String o Int. È possibile?

(interrogazione here)

Answer 1

Non proprio possibile, come dici tu, ma è possibile farlo utilizzando il modello tipo di classe. Ad esempio, dal here:

sealed abstract class Acceptable[T] 
object Acceptable { 
    implicit object IntOk extends Acceptable[Int] 
    implicit object LongOk extends Acceptable[Long] 
} 

def f[T: Acceptable](t: T) = t 

scala> f(1) 
res0: Int = 1 

scala> f(1L) 
res1: Long = 1 

scala> f(1.0) 
<console>:8: error: could not find implicit value for parameter ev: Acceptable[Double] 
f(1.0) 
^ 

EDIT

Questo funziona se la classe e l'oggetto sono compagni. Su REPL, se si digita ciascuno su una linea diversa (cioè, un "risultato" appare tra di loro), non sono compagni. È possibile digitare è come qui di seguito, però:

scala> sealed abstract class Acceptable[T]; object Acceptable { 
    | implicit object IntOk extends Acceptable[Int] 
    | implicit object LongOk extends Acceptable[Long] 
    | } 
defined class Acceptable 
defined module Acceptable 

Answer 2

C'è questo hack:

implicit val x: Int = 0 
def foo(a: List[Int])(implicit ignore: Int) { } 

implicit val y = "" 
def foo(a: List[String])(implicit ignore: String) { } 

foo(1::2::Nil) 
foo("a"::"b"::Nil) 

Vedi http://michid.wordpress.com/2010/06/14/working-around-type-erasure-ambiguities-scala/

E anche questo question.

Answer 3

È possibile ottenere un piccolo chilometraggio dal tipo Either. Tuttavia, l'una o l'altra gerarchia è sigillata e la gestione di più di due tipi diventa ingombrante.

scala> implicit def string2either(s: String) = Left(s) 
string2either: (s: String)Left[String,Nothing] 

scala> implicit def int2either(i: Int) = Right(i) 
int2either: (i: Int)Right[Nothing,Int] 

scala> type SorI = Either[String, Int] 
defined type alias SorI 

scala> def foo(a: SorI) {a match { 
    |  case Left(v) => println("Got a "+v) 
    |  case Right(v) => println("Got a "+v) 
    | } 
    | } 
foo: (a: SorI)Unit 

scala> def bar(a: List[SorI]) { 
    | a foreach foo 
    | } 
bar: (a: List[SorI])Unit 

scala> 

scala> foo("Hello") 
Got a Hello 

scala> foo(10) 
Got a 10 

scala> bar(List(99, "beer")) 
Got a 99 
Got a beer 

Answer 4

Un'altra soluzione è classi involucro:

case class IntList(l:List[Int]) 
case class StringList(l:List[String]) 

implicit def li2il(l:List[Int]) = IntList(l) 
implicit def ls2sl(l:List[String]) = StringList(l) 

def foo(list:IntList) = { println("Int-List " + list.l)} 
def foo(list:StringList) = { println("String-List " + list.l)} 

Answer 5

Mostra http://cleverlytitled.blogspot.com/2009/03/disjoint-bounded-views-redux.html