Recherche d'un exemple d'utilisation de classe de type qui fonctionnera dans les scripts Scala 2.7.7 et 2.8

Question

Salut, je cherche un exemple rapide d'utilisation de classe de type dans Scala qui fonctionnera dans les environnements 2.7.7 et 2.8. Tous les exemples que j'ai vus ne fonctionnent que dans 2.8, mais on m'a dit que les classes de types sont également implémentables dans 2.7.7.

La seule autre exigence est que l'utilisation doit pouvoir fonctionner dans un script.

Des exemples appréciés! 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))) 

Le code fonctionne dans les Scala 2.7.7 et 2.8.0 (testé en ce moment à la fois), bien que la définition implicite est inutile (et potentiellement dangereux dans certaines situations) dans Scala 2.8.