¿Cómo fijo múltiples límites de tipo con OR en Scala

Question

¿Es posible hacer algo como esto en Scala:

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

Es decir, el tipo A podría ser una String o Int. es posible?

(pregunta similares here)

Answer 1

No

realmente posible como usted dice, pero puede hacerlo utilizando el patrón de clase de tipo. Por ejemplo, desde 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) 
^ 

EDITAR

Esto funciona si la clase y el objeto son compañeros. En REPL, si escribe cada uno en una línea diferente (es decir, aparece un "resultado" entre ellos), no son compañeros. Puede escribir que, como a continuación, sin embargo:

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

No es este truco:

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) 

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

Y también esta question.

Answer 3

Puede obtener un poco de millaje del tipo Cualquiera. Sin embargo, la jerarquía de Either está sellada y manejar más de dos tipos resulta engorroso.

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

Otra solución es clases de contenedor:

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

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