Wie richte ich mehrere geODERten Typ Grenzen in Scala

Question

Ist es möglich, in Scala, so etwas zu tun:

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

Das heißt, der Typ A ein String oder Int sein könnte. Ist das möglich?

(ähnliche Frage here)

Answer 1

nicht wirklich möglich, wie Sie es nennen, aber Sie können es tun, um die Typklasse Muster. Zum Beispiel von 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

Dies funktioniert, wenn Klasse und Objekt sind Begleiter. Wenn Sie bei REPL auf eine andere Zeile tippen (dh ein "Ergebnis" zwischen ihnen erscheint), sind sie keine Begleitpersonen. Sie können es wie unten geben, aber:

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

Es ist dieser 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) 

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

Und auch dieses question.

Answer 3

Sie könnten ein wenig Kilometer vom Typ Beide erhalten. Die Entweder-Hierarchie ist jedoch versiegelt und die Handhabung von mehr als zwei Typen wird mühsam.

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

Eine andere Lösung ist Wrapper-Klassen:

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

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