Jak skonfigurować wiele granic typu ORed Scala

Question

Czy można zrobić coś takiego w Scala:

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

Oznacza to, że typ A może być String lub Int. czy to możliwe?

(Podobne pytanie here)

Answer 1

Nie bardzo możliwe, jak to ująłeś, ale można to zrobić przy użyciu wzorca klasy typu. Na przykład, od 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

To działa, jeśli klasa i obiekt są towarzyszami. W REPL, jeśli wpiszesz każdą z nich w innym wierszu (tzn. Pojawi się między nimi "wynik"), nie są one towarzyszami. Można wpisać go jak poniżej, choć:

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

Jest to 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) 

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

a także to question.

Answer 3

Możesz uzyskać niewielki przebieg z dowolnego typu. Jednak obie hierarchie są zapieczętowane, a obsługa więcej niż dwóch typów staje się uciążliwa.

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

Innym rozwiązaniem jest klas Wrapper:

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

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