scala powrót na pierwszą Niektórzy w liście

Question

Mam listę l:List[T1] i obecnie jestem w następujący sposób:

myfun : T1 -> Option[T2] 
val x: Option[T2] = l.map{ myfun(l) }.flatten.find(_=>true) 

Funkcja myfun zwróci None albo pół, spłaszczyć wyrzuca wszystkie Żaden oraz znaleźć Zwraca pierwszy element listę, jeśli istnieje.

Wydaje mi się to trochę hackowate. Im myślę, że może istnieć jakieś do zrozumienia lub podobne, które zrobi to nieco mniej marnotrawny lub bardziej sprytny. Na przykład: Nie potrzebuję żadnych kolejnych odpowiedzi, jeśli myfun zwraca dowolnąSome podczas map z listy .

Answer 1

Jak o:

l.toStream flatMap (myfun andThen (_.toList)) headOption 

Stream jest leniwy, więc to nie będzie mapować wszystko z góry, ale to nie będzie przemapować rzeczy albo. Zamiast spłaszczania rzeczy, przekonwertuj Option na List, aby można było użyć flatMap.

Answer 2

No to jest prawie, ale nie całkiem

val x = (l flatMap myfun).headOption 

Ale wracają do Option zamiast List od myfun, więc to może nie działać. Jeśli tak (nie mam rEPL pod ręką), a następnie spróbuj zamiast:

val x = (l flatMap(myfun(_).toList)).headOption 

Answer 3

Cóż, do-zrozumienia równoważne jest całkiem proste

(for(x<-l, y<-myfun(x)) yield y).headOption 

co jeśli faktycznie wykonać tłumaczenie odrabia to samo, co dawały oxbow_lakes. Zakładając uzasadnione lenistwo List.flatmap, jest to zarówno czyste, jak i wydajne rozwiązanie.

Answer 4

Od 2017 r. Poprzednie odpowiedzi wydają się nieaktualne. Przeprowadziłem testy porównawcze (lista 10 milionów int, pierwszy mecz mniej więcej pośrodku, Scala 2.12.3, Java 1.8.0, 1.8 GHz Intel Core i5).O ile nie zaznaczono inaczej, list i map mają następujące typy:

list: scala.collection.immutable.List 
map: A => Option[B] 

Wystarczy zadzwonić map na liście: ~ 1000 ms

list.map(map).find(_.isDefined).flatten 

najpierw wywołać toStream na liście: ~ 1200 ms

list.toStream.map(map).find(_.isDefined).flatten 

Zadzwoń na toStream.flatMap z listy: ~ 450 ms

list.toStream.flatMap(map(_).toList).headOption 

połączeń flatMap na liście: ~ 100ms

list.flatMap(map(_).toList).headOption 

najpierw wywołać iterator na liście: ~ 35 ms

list.iterator.map(map).find(_.isDefined).flatten 

funkcji rekurencyjnej find(): ~ 25 ms

def find[A,B](list: scala.collection.immutable.List[A], map: A => Option[B]) : Option[B] = { 
    list match { 
    case Nil => None 
    case head::tail => map(head) match { 
     case None => find(tail, map) 
     case result @ Some(_) => result 
    } 
    } 
} 

Funkcja iteracyjna find(): ~ 25 ms

def find[A,B](list: scala.collection.immutable.List[A], map: A => Option[B]) : Option[B] = { 
    for (elem <- list) { 
    val result = map(elem) 
    if (result.isDefined) return result 
    } 
    return None 
} 

można dodatkowo przyspieszyć rzeczy za pomocą Java zamiast kolekcji Scala i styl mniej funkcjonalne.

pętli nad wskaźników w java.util.ArrayList: ~ 15 ms

def find[A,B](list: java.util.ArrayList[A], map: A => Option[B]) : Option[B] = { 
    var i = 0 
    while (i < list.size()) { 
    val result = map(list.get(i)) 
    if (result.isDefined) return result 
    i += 1 
    } 
    return None 
} 

pętli nad wskaźników w java.util.ArrayList z funkcją powrotu null zamiast None: ~ 10 ms

def find[A,B](list: java.util.ArrayList[A], map: A => B) : Option[B] = { 
    var i = 0 
    while (i < list.size()) { 
    val result = map(list.get(i)) 
    if (result != null) return Some(result) 
    i += 1 
    } 
    return None 
} 

(Oczywiście, zazwyczaj zadeklaruj typ parametru jako java.util.List, a nie java.util.ArrayList. Wybrałem ten ostatni tutaj, ponieważ jest to klasa, której użyłem do testów porównawczych.wyświetli inną wydajność - większość będzie gorsza.)