come usare>< <= > = come funzioni?

Question

Ho bisogno di definire alcune classi di casi come la seguente:

case class Gt(key: String, value: Any) extends Expression { 
    def evalute[V, E](f: String => Any) = { 
    def compare(v: Any): Boolean = { 
     v match { 
     case x: Number => x.doubleValue > value.asInstanceOf[Number].doubleValue 
     case x: Array[_] => x.forall(a => compare(a)) 
     case x => x.toString > value.toString 
     } 
    } 
    compare(f(key)) 
    } 
} 

non mi piace ripetere che, per> <> = e < =

inoltre ho provato questo:

trait Expression { 
    def evalute[V, E](f: String => Any) = true 

    def compare(v: Any, value: Any, cp: (Ordered[_], Ordered[_]) => Boolean): Boolean = { 
    v match { 
     case x: Number => cp(x.doubleValue, value.asInstanceOf[Number].doubleValue) 
     case x: Array[_] => x.forall(a => compare(a, value, cp)) 
     case x => cp(x.toString, value.toString) 
    } 
    } 
} 
case class Gt(key: String, value: Any) extends Expression { 
    def evalute[V, E](f: String => Any) = { 
    compare(f(key), value, ((a, b) => a > b)) 
    } 
} 

ma che non funziona :(

error: could not find implicit value for parameter ord: scala.math.Ordering[scala.math.Ordered[_ >: _$1 with _$2]] 
compare(f(key), value, ((a, b) => a > b)) 

Esiste un modo per passare un operatore come funzione in scala?

Answer 1

Non ho familiarità con Scala, sembra avere il supporto per funzioni anonime/lambda: http://www.scala-lang.org/node/133

Answer 2

In Scala, quelli non sono gli operatori, ma i metodi. Puoi sollevare qualsiasi metodo per una funzione mettendo un trattino basso dopo di esso. per esempio.

Welcome to Scala version 2.8.0.final (Java HotSpot(TM) Client VM, Java 1.6.0_21). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> val f: (Int => Boolean) = 1 <= _ 
f: (Int) => Boolean = <function1> 

scala> (0 to 2).map(f) 
res0: scala.collection.immutable.IndexedSeq[Boolean] = Vector(false, true, true) 

Answer 3

(a, b) => a > b funziona correttamente. Il tuo problema è con i tipi.

1. Quali sono V e E in evalute[V, E] dovrebbe essere?

2. Lo si passa (a, b) => a > b come parametro cp: (Ordered[_], Ordered[_]) => Boolean. Quindi hai a: Ordered[_] e b: Ordered[_]. Che è lo stesso di a: Ordered[X] forSome {type X} e b: Ordered[Y] forSome {type Y}. Con questi tipi, a > b non ha senso.