Suma listy opcji w Scali

Question

Jak mogę podsumować listę opcji List[Option[Double]] z następującymi regułami?

• List(Some(1), ..., Some(n)) --> Some(1 + ... + n)
• List(Some(1), ..., Some(n), None) --> None
• List(None, ..., None) --> None

Answer 1

Aby uniknąć przechodzenie całej listy z forall aby sprawdzić, czy cały zestaw opcji jest zdefiniowana, można użyć foldLeft i wykorzystaj fakt, że możesz uzyskać None przy pierwszym znalezieniu pustego elementu w łańcuchu.

def sumList(list: List[Option[T]])(implicit ev: Numeric[T]): Option[T] = { 
    list.foldLeft(Option(ev.zero)) { case (acc, el) => 
    el.flatMap(value => acc.map(ac => ev.plus(ac, value))) 
    } 
} 

sumList(List(None, None, Some(5))) 
res10: Option[Int] = None 

scala> sumList(List(None, None, Some(5F))) 
res11: Option[Float] = None 

scala> sumList[Double](List(None, None, None)) 
res13: Option[Double] = None 

scala> sumList(List(Some(5), Some(15))) 
res14: Option[Int] = Some(20) 

i uniknąć return można po prostu użyć rekurencji (aktualizacji, zwrot nie jest potrzebny powyżej, ale może to jest łatwiejsze do naśladowania):

@annotation.tailrec 
def sumListRec[T](list: List[Option[T]], acc: T)(implicit ev: Numeric[T]): Option[T] = { 
    list match { 
    // if the list still has elements 
    case head :: tail => head match { 
     // add the value to the accumulator and keep going 
     case Some(value) => sumListRec(tail, ev.plus(acc, value)) 
     // if you found a None, disregard whatever sum we built so far 
     // and just return None 
     case None => None 
    } 
    // If the list is empty, it means we've successfully reached 
    // the end of the list, so we just return the sum we built. 
    case Nil => Some(acc) 
    } 
} 

oglądać go w akcji:

scala> sumListRec(List(Some(5D), Some(5D)), 0D) 
res5: Option[Double] = Some(10.0) 

sumListRec(List(None, None, Some(5D)), 0D) 
res2: Option[Double] = None 

scala> sumListRec(List(None, None), 0D) 
res6: Option[Double] = None 

Answer 2

Jeśli używasz Scalaz to jest bardzo proste:

targetList.sequence.map(_.suml) 

Answer 3

Możesz to zrobić w ten sposób. Edytuj: zmienił kod, aby powrócić natychmiast po zetknięciu się z None. Przyznaję, że ta optymalizacja ani nie komplikuje kodu zbyt mocno, ani nie utrudnia czytelności (jak myślałem wcześniej).

def sumOpt(list: List[Option[Double]]): Option[Double] = list.reduce((x,y) => { 
    if (x.isEmpty || y.isEmpty) return None 
    else Some(x.get + y.get) 
}) 
sumOpt(list) 

Answer 4

Jest jeszcze prostszy sposób tylko przy użyciu krotnie:

val ls = List(Some(2.1d), Some(5.6d), Some(4.3d), Some(1.2)) 

ls.fold(Option(0d))((rs,x) => for(n <- x; m <- rs) yield {n+m}) 

=> Niektóre (13,2)

val ls = List(Some(2.1d),None, Some(5.6d), Some(4.3d), Some(1.2)) 

ls.fold(Option(0d))((rs,x) => for(n <- x; m <- rs) yield {n+m}) 

=> Brak