scala, filter, eine Sammlung basiert auf mehreren Voraussetzungen

Ich habe einen code wie:

val strs = List("hello", "andorra", "trab", "world")
def f1(s: String) = !s.startsWith("a")
def f2(s: String) = !s.endsWith("b")

val result = strs.filter(f1).filter(f2)

nun f1 und f2 angewendet werden soll, beruht auf einem Umstand, wie zum Beispiel:

val tmp1 = if (cond1) strs.filter(f1) else strs
val out  = if (cond2) tmp1.filter(f2) else tmp1

ist es ein schöner Weg, dies zu tun, ohne eine zwischenvariable mit einem tmp1?

eine Möglichkeit zu filtern, basierend auf einer Liste von Funktionen, wie:

val fs = List(f1 _,f2 _)
fs.foldLeft(strs)((fn, list) => list.filter(fn))

aber dann würde ich brauchen, um zu bauen eine Liste von Funktionen auf der Grundlage der Bedingungen (und ja, ich würde sich das problem mit einem temporären string-Liste variable, um eine temporäre Funktion list-variable (oder sollte ich brauchen, um eine veränderliche Liste)).

Ich Suche so etwas (natürlich nicht kompilieren, sonst hätte ich bereits die Antwort auf die Frage):

val result = 
  strs
    .if(cond1, filter(f1))
    .if(cond2, filter(f2))

Klingt wie Sie wollen, die eine Liste von Tupeln (Zustand,filterPredicate). Anschließend können Sie diese Liste filtern basierend auf, ob oder nicht der Zustand (z.B. _._1) hält. Jetzt haben Sie eine Liste von Funktionen, die Sie anwenden möchten. Sie können dann diese Karte mit dem string und reduzieren Sie mit && (Logik und). Sorry, wenn es zu wellig ist.
danke, das ist eine gute Idee, auch, aber ich suchte etwas, das mehr wie noah ' s Antwort.

InformationsquelleAutor David Portabella | 2013-07-01

scala

8

Konnte Sie problemlos verwenden Sie eine implizite Klasse geben Sie diese syntax:
```
  val strs = List("hello", "andorra", "trab", "world")

  def f1(s: String) = !s.startsWith("a")

  def f2(s: String) = !s.endsWith("b")

  val cond1 = true
  val cond2 = true

  implicit class FilterHelper[A](l: List[A]) {
    def ifFilter(cond: Boolean, f: A => Boolean) = {
      if (cond) l.filter(f) else l
    }
  }

  strs
    .ifFilter(cond1, f1)
    .ifFilter(cond2, f2)

res1: List[String] = List(hello, world)
```
Ich würde verwendet haben if wie der name der Methode, aber es ist ein reserviertes Wort.
- das ist das, was ich suchte; dann kann ich den Prozess in mehrere Schritte, wie in strs.filter(...).anzeigen(...).ifFilter(...).anzeigen(...).ifFilter(...). Ich würde nur ändern, "l.filter(ein => !cond || filter(a))" durch "if (cond) l.filter(filter) else l" zu vermeiden, verwenden Sie einen filter mit einer immer wahren Bedingung.
- Ich aktualisierte den code, um die änderung widerzuspiegeln, keine Notwendigkeit zu Durchlaufen, wenn Sie nicht müssen.
InformationsquelleAutor Noah
4

Sie können dies tun, durch die Summe Ihrer Prädikat-Funktionen.

Beobachten, dass ein filterprädikat A => Boolean hat eine append-operation:
```
def append[A](p1: A => Boolean, p2: A => Boolean): A => Boolean =
  a => p1(a) && p2(a)
```
Und ein identity-Wert:
```
def id[A]: A => Boolean =
  _ => true
```
erfüllt die Bedingung, dass für jedes Prädikat p: A => Boolean, append(p, id) === p.

Dadurch vereinfacht sich das problem von einschließlich/ausschließlich ein Prädikat, das auf Grundlage einer Bedingung: wenn die Bedingung false ist, schließen Sie einfach das id Prädikat. Es hat keine Auswirkung auf den filter, weil es gibt immer true.

Um die Summe der Prädikate:
```
def sum[A](ps: List[A => Boolean]): A => Boolean =
  ps.foldLeft[A => Boolean](id)(append)
```
Beachten Sie, dass wir Falten auf id, so dass, wenn ps leer ist, bekommen wir die Identität Prädikat, d.h. ein filter, der nichts tut, als Sie erwarten würden.

Alles zusammen:
```
val predicates = List(cond1 -> f1 _, cond2 -> f2 _)

strs.filter(sum(predicates.collect { case (cond, p) if cond => p }))
//List(hello, world)
```
Beachten Sie, dass die Liste strs wurde nur einmal Durchlaufen.

Nun, für die Scalaz-version der oben genannten:
```
val predicates = List(cond1 -> f1 _, cond2 -> f2 _)

strs filter predicates.foldMap {
  case (cond, p) => cond ?? (p andThen (_.conjunction))
}
//List("hello", "world")
```
- das problem ist, dass wenn cond1=false, die Sie sich bewerben, so etwas wie "strs.filter(true)", der langsamer ist als einfach wieder die Liste selbst.
- David: aber dann, wenn beide Bedingungen wahr sind, die wir nur noch anwenden filter einmal. Für n Prädikate, die akzeptierten Lösung führen filter bis zu n mal!
- Werden Sie sagen, dass diese append und Identität id Operationen/Funktionen, die vorhanden sind, oder einfach nur, dass Sie definiert werden können? Ich kann Sie nicht finden in Scala 2.10.
InformationsquelleAutor Ben James

@Noah ' s Antwort ist gut, und Sie können es nehmen und verallgemeinern es weiter, wenn Sie wollen in der Lage sein, um irgendeine Art von Aktion, die auf einer Liste gibt eine neue Liste, die einer Bedingung, wenn Sie die folgende änderung:

implicit class FilterHelper[A](l: List[A]) {
  def ifthen[B](cond: Boolean, f:(List[A]) => List[B]) = {
    if (cond) f(l) else l
  }
}

Dann verwenden Sie es wie diese:

val list = List("1", "2")    
val l2 = list.ifthen(someCondition, _.filter(f1)
val l3 = list.ifthen(someOtherCondition, _.map(_.size))

InformationsquelleAutor cmbaxter

2

Wäre es wohl eher einfach so, dass es nur den Zustand in Ihrem block für den filter, etwa so:
```
val result = strs filter (x => !cond1 || f1(x)) filter (x => !cond2 || f2(x))
```
wobei das Ergebnis wäre ein filter angewendet wird, wenn die Bedingung erfüllt ist, oder einfach wieder die gleiche Liste.
- Ja, aber ich denke, der Punkt ist, warum auch die Funktion anwenden, wenn wenn nicht alles tun. Warum die Liste Durchlaufen (sagen, es ist sehr groß), wenn Sie nicht haben, um?
- Schreiben konnte strs filter { x => (!cond1 || f1(x)) && (!cond2 || f2(x)) } so müssen Sie nur einmal Durchlaufen
InformationsquelleAutor James

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.