coalescenza opzioni in Scala

Question

maggior parte delle implementazioni di SQL (questa domanda non ha nulla a che fare con SQL, è solo un esempio) offrono la funzione COALESCE(x1,x2,...,xn) che restituisce x1 se non è NULL, x2 altrimenti solo se x2 non è NULL né e così sopra. Se tutti i valori xi sono NULL, il risultato è NULL.

Volevo ottenere qualcosa come SQL COALESCE in Scala per i valori OptionNULL sostituito da None. Vi darò alcuni esempi:

> coalesce(None,Some(3),Some(4)) 
res0: Some(3) 

> coalesce(Some(1),None,Some(3),Some(4)) 
res1: Some(1) 

> coalesce(None,None) 
res2: None 

Così ho implementato come:

def coalesce[T](values: Option[T]*): Option[T] = 
    (List[T]() /: values)((prev: List[T], cur: Option[T]) => 
          prev:::cur.toList).headOption 

Funziona bene, ma mi chiedo se esiste già qualcosa di simile funzione implementata come parte della Scala.

Answer 1

Shorter ancora, si potrebbe usare collectFirst. Questo lo farà in un solo passaggio, con al massimo un attraversamento della collezione.

def coalesce[A](values: Option[A]*): Option[A] = 
    values collectFirst { case Some(a) => a } 


scala> coalesce(Some(1),None,Some(3),Some(4)) 
res15: Option[Int] = Some(1) 

scala> coalesce(None,None) 
res16: Option[Nothing] = None 

Answer 2

Find prima opzione definita:

def coalesce[T](values: Option[T]*): Option[T] = 
    values.find(_.isDefined).flatten 

Answer 3

ne dite:

values.flatten.headOption 

Questo funziona poiché Option è implicitamente convertibile in Iterable, così flatten funziona più o meno nello stesso modo in cui una lista di liste.

Answer 4

Auto risposta:

Il meccanismo nativo (senza implementare una funzione coalesce) è il concatenamento di chiamate a orElse metodo:

> None.orElse(Some(3)).orElse(Some(4)) 
res0: Option[Int] = Some(3) 

> Some(1).orElse(None).orElse(Some(3)).orElse(Some(4)) 
res1: Option[Int] = Some(1) 

> None.orElse(None) 
res2: Option[Nothing] = None