scala - Min/max con Opzione [T] per eventuale Seq? Vuoto?

Question

Sto facendo un po 'di ginnastica alla Scala dove ho lo Seq[T] nel quale cerco di trovare l'elemento "più piccolo". Questo è quello che faccio adesso:

val leastOrNone = seq.reduceOption { (best, current) => 
    if (current.something < best.something) current 
    else best 
} 

Funziona bene, ma non sono abbastanza soddisfatto - è un po 'lungo per una cosa così semplice, e I don't care much for "if"s. Utilizzando minBy sarebbe molto più elegante:

val least = seq.minBy(_.something) 

... ma min e minBy generano eccezioni quando la sequenza è vuota. Esiste un modo idiomatico e più elegante di trovare l'elemento più piccolo di una lista potenzialmente vuota come Option?

Answer 1

seq.reduceOption(_ min _) 

fa ciò che vuoi?

---

Edit: Ecco un esempio che incorporano il _.something:

case class Foo(a: Int, b: Int) 
val seq = Seq(Foo(1,1),Foo(2,0),Foo(0,3)) 
val ord = Ordering.by((_: Foo).b) 
seq.reduceOption(ord.min) //Option[Foo] = Some(Foo(2,0)) 

o, come metodo generico:

def minOptionBy[A, B: Ordering](seq: Seq[A])(f: A => B) = 
    seq reduceOption Ordering.by(f).min 

che si potrebbe richiamare con minOptionBy(seq)(_.something)

Answer 2

In Haskell si sarebbe avvolgere il minimumBy chiamata come

least f x | Seq.null x = Nothing 
      | otherwise = Just (Seq.minimumBy f x) 

Answer 3

ne dici di questo?

import util.control.Exception._ 
allCatch opt seq.minBy(_.something) 

Oppure, più dettagliato, se non si vuole ingoiare altre eccezioni:

catching(classOf[UnsupportedOperationException]) opt seq.minBy(_.something) 

In alternativa, è possibile magnaccia tutte le collezioni con qualcosa di simile:

import collection._ 

class TraversableOnceExt[CC, A](coll: CC, asTraversable: CC => TraversableOnce[A]) { 

    def minOption(implicit cmp: Ordering[A]): Option[A] = { 
    val trav = asTraversable(coll) 
    if (trav.isEmpty) None 
    else Some(trav.min) 
    } 

    def minOptionBy[B](f: A => B)(implicit cmp: Ordering[B]): Option[A] = { 
    val trav = asTraversable(coll) 
    if (trav.isEmpty) None 
    else Some(trav.minBy(f)) 
    } 
} 

implicit def extendTraversable[A, C[A] <: TraversableOnce[A]](coll: C[A]): TraversableOnceExt[C[A], A] = 
    new TraversableOnceExt[C[A], A](coll, identity) 

implicit def extendStringTraversable(string: String): TraversableOnceExt[String, Char] = 
    new TraversableOnceExt[String, Char](string, implicitly) 

implicit def extendArrayTraversable[A](array: Array[A]): TraversableOnceExt[Array[A], A] = 
    new TraversableOnceExt[Array[A], A](array, implicitly) 

E quindi scrivi semplicemente seq.minOptionBy(_.something).

Answer 4

Difficilmente un'opzione per ogni lista più grande a causa della complessità O(nlogn):

seq.sortBy(_.something).headOption 

Answer 5

Una cassetta di sicurezza, compatto e la versione O(n) con Scalaz:

xs.nonEmpty option xs.minBy(_.foo) 

Answer 6

Scala consente di acquisire l'errore con Try. Scriviamo una funzione che fa uso di esso:

def min[T <% Ordered[T]](s: Seq[T]) = util.Try(s.min).toOption 

Ora diamo prova che:

scala> min(Seq(1,2,3)) 
res4: Option[Int] = Some(1) 

scala> min(Seq.empty[Int]) 
res5: Option[Int] = None 

Answer 7

Ho lo stesso problema prima, così mi si estende verso ordinato e implementare la funzione di confronto. ecco esempio:

case class Point(longitude0: String, latitude0: String) extends Ordered [Point]{ 

    def this(point: Point) = this(point.original_longitude,point.original_latitude) 
    val original_longitude = longitude0 
    val original_latitude = latitude0 

    val longitude = parseDouble(longitude0).get 
    val latitude = parseDouble(latitude0).get 

    override def toString: String = "longitude: " +original_longitude +", latitude: "+ original_latitude 

    def parseDouble(s: String): Option[Double] = try { Some(s.toDouble) } catch { case _ => None } 

    def distance(other: Point): Double = 
    sqrt(pow(longitude - other.longitude, 2) + pow(latitude - other.latitude, 2)) 

override def compare(that: Point): Int = { 
    if (longitude < that.longitude) 
    return -1 
    else if (longitude == that.longitude && latitude < that.latitude) 
    return -1 
    else 
    return 1 
} 
} 

così se ho un seguenti del Point posso chiedere per max o il metodo min

var points = Seq[Point]() 

val maxPoint = points.max 
val minPoint = points.min