Vous recherchez par exemple de type utilisation de classe qui fonctionnera dans Scala 2.7.7 et 2.8 scripts

Question

Salut, je suis à la recherche d'un exemple rapide de l'utilisation de la classe de type à Scala qui fonctionnera dans les deux 2.7.7 et 2.8 environnements.

Tous les exemples que je l'ai vu le travail que dans 2,8, mais j'ai dit que les classes de type sont mis en œuvre dans 2.7.7 aussi bien.

La seule autre exigence est que l'usage doit être capable de travailler dans un script.

Les exemples apprécié! Merci

Answer 1

Je suis allé avec une solution dans ce sens:

//---------- Classes without needed behavior
case class Point(x: Double, y: Double)
trait Shape {}
case class Circle(center: Point, radius: Double) extends Shape {}
case class Rectangle(lowerLeft: Point, upperRight: Point) extends Shape {}


val circle = Circle(Point(1.0, 2.0), 5.0)
val rectangle = Rectangle(Point(-2.0, -1.0), Point(4.0, 5.0))


//----------- Support for new behavior I want to add

// Create exception to handle non supported subclasses
case class NewMethodNotSupported(a: Any)
    extends RuntimeException(a.toString + ".newMethod() not supported")

class NewBehavior(shape: Shape) {
    def newMethod() = shape match {
        case c: Circle => doMethod(c)
        case r: Rectangle => doMethod(r)
        case _ => throw NewMethodNotSupported(shape)
    }
    private
    def doMethod(s: Shape) = println(s) // print to standard out.
}

object NewBehavior {
    // invoked by the compiler
    implicit def shapeToNewBehavior(s: Shape) = new NewBehavior(s)
}

// bring the implicit method in scope
import NewBehavior._
// --------- End of new behavior support        


// Test behavior support:
println("Test that new behavior is added:")
circle.newMethod()
rectangle.newMethod()

// Create a non supported shape class
case class Triangle(vertex1: Point,
        vertex2: Point, vertex3: Point) extends Shape {}

val triangle = Triangle(Point(-1.0,0.0), Point(1.0,0.0), Point(0.0,1.0))

// Catch exception thrown by trying to call method from unsupported shape
try{    
    println("\nTest method call from unsupported shape:")
    triangle.newMethod()
} catch {
    case dns: NewMethodNotSupported => println(dns); System.exit(-1)
    case unknown => println("Uknown exception " + unknown); System.exit(-1)
}

Answer 2

Je suppose que vous pourriez faire quelque chose comme ceci:

def max[A](list: List[A])(implicit ord: Ordering[A]): A = {
  list.tail.foldLeft(list.head) ((a, b) => if (ord.lt(a, b)) b else a)
}

implicit def toOrdering[A <% Ordered[A]]: Ordering[A] = new Ordering[A] {
    def compare(a: A, b: A): Int = (a < b, b < a) match {
        case (true, _) => -1
        case (_, true) => 1
        case _ => 0
    }
}

println(max(List(1, 2, 3, 2, 1)))

Les pistes de code à la fois Scala 2.7.7 et 2.8.0 (testé en ce moment à la fois), bien que la définition implicite est inutile (et peut-être dangereux dans certaines situations) à Scala 2.8.