Ist es zulässig, zu reduzieren auf einen leeren Menge von Mengen?

Sollte dies nicht funktionieren?

> val setOfSets = Set[Set[String]]()    
setOfSets: scala.collection.immutable.Set[Set[String]] = Set()

> setOfSets reduce (_ union _)
java.lang.UnsupportedOperationException: empty.reduceLeft
  at scala.collection.TraversableOnce$class.reduceLeft(TraversableOnce.scala:152)
  [...]

reduzieren ist ein Spezialfall der Faltung. Sie wollen wahrscheinlich foldLeft ausgehend von der leeren Menge.
Das ist wahr. Aber was ist, wenn ich dabei war (_ intersect _)?
Was würden Sie erwarten, dass der Rückgabewert in diesem Fall? In der Regel, was sollte reduce/reduceLeft/reduceRight Gegenzug, wenn ihm eine leere Sammlung? Der Funktion sind Sie die Verringerung mit Typ A => B => B für eine Sammlung C[A], so haben Sie keine Möglichkeit, zu produzieren, die einen Wert vom Typ B aus der Luft gegriffen.
Die Absicht ist es, "geben Sie mir nur die strings, die angezeigt werden, in der alle Sätze, die Sie haben". Wenn die Menge der gefundenen sets leer ist, würde man erwarten, dass das Ergebnis leer sein. Weil, wie reduce arbeitet, der Spezialfall einer leeren Menge hat, die behandelt werden, mit einer Bedingung zu liefern, der fehlende Typ B. Ich hatte gehofft, für etwas mehr elegant.
Ergebnis [wird] leer" ist nicht ein allgemeiner Begriff für eine beliebige B. Jedoch, Sie sollten check out Scalaz ist Foldable trait; insbesondere, Blick auf foldMap[A,M](t: F[A], f: A => M)(implicit m: Monoid[M]): M. Ein monoid ist einfach ein Typ mit einer assoziativen binären operation (z.B. ++ für Listen union für Mengen * für zahlen, ...) und eine Identität für Sie, dass der Betrieb (List(), Set(), 1). <weiter...>
<...weiter> Mit foldMap können Sie angeben, wie Sie Elemente Ihrer Sammlung in die Elemente ein monoid, und dann implizit verbindet diese mit der binären operation und der null-Fall. Dies funktioniert, weil für monoiden, die "leere" ist ein generischer Begriff (und so ist "die Zusammenführung von zwei Objekten"). (In anderen Worten, t.foldMap(f) wird t.fold((a,m) => f(a) |+| m)(mzero[M]), wo |+| ist der binäre operator und mzero ist die Identität.)

InformationsquelleAutor gladed | 2011-08-08

20

Reduzieren (Links und rechts) kann nicht angewendet werden auf eine leere Sammlung.

Konzeptionell:
```
myCollection.reduce(f)
```
ähnlich ist:
```
myCollection.tail.fold( myCollection.head )( f )
```
Also die Abholung muss mindestens ein element.
- Aber ich habe nicht verwenden reduceLeft oder reduceRight; ich verwendet reduce, die nicht geben Sie eine Bestellung.
- Trotzdem kann ich verstehen, dass reduzieren, ist grundsätzlich unvereinbar mit der Idee eine leere Liste. Und ich sehe die Einschränkung in die scaladoc jetzt. Es ist begraben in dem "zurück" - Abschnitt: "das Ergebnis Der Anwendung reduzieren operator op zwischen allen Elementen wenn die Auflistung ist nicht leer." ich wünschte, hatte angegeben, im Voraus statt.
- Warum ist die Reihenfolge wichtig?
- Die Bestellung ist nicht wichtig, das problem zu verstehen. Die Sätze sind nicht bestellt.
- IMHO, Java8 habe dieses Recht, indem Sie reduce Gegenzug eine Optional statt das tatsächliche Ergebnis. Also, wenn die Sammlung leer ist, bekommst du nur zurück None statt eine Laufzeit-exception.
- True, können Sie dies manuell tun, wenn Sie verwenden möchten, zu reduzieren, d.h. pattern-match auf der Liste ersten.
- Fühlt sich an wie reduzieren ist fehlerhaft. Wie sagte Sanjay zurückgeben sollte eine Option sein, wenn es spezielle Fälle, die behandelt werden müssen. Lektion gelernt ist, Sie nur vermeiden, reduzieren und Falten verwenden.
- Du hast Recht, aber reduceOption gibt es auch.
InformationsquelleAutor paradigmatic
12

Sollte dies tun, was Sie wollen:
```
setOfSets.foldLeft(Set[String]())(_ union _)
```
Obwohl ich noch nicht verstanden die Anforderung nicht an eine Bestellung.
- Schlage vor, Sie verwenden Gesetzt.empty[String] über Set[String](), es gibt keine Notwendigkeit, erstellen Sie eine neue Instanz der leeren Menge.
InformationsquelleAutor soc

Ab Scala 2.9 meisten Sammlungen sind nun mit den reduceOption Funktion (als äquivalent zu reduce), die unterstützt den Fall von leeren Sequenzen durch Rücksendung einer Option Ergebnis:

Set[Set[String]]().reduceOption(_ union _)
//Option[Set[String]] = None
Set[Set[String]]().reduceOption(_ union _).getOrElse(Set())
//Set[String] = Set()
Set(Set(1, 2, 3), Set(2, 3, 4), Set(5)).reduceOption(_ union _).getOrElse(Set())
//Set[Int] = Set(5, 1, 2, 3, 4)

Dies sollte aktualisiert werden akzeptiert Antwort.

InformationsquelleAutor Xavier Guihot

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.