Gibt es eine einfache Möglichkeit, in verschachtelten Seqs in Scala aus dem Rahmen zu gehen?

Question

Ich habe einen Vektor von Vektoren, auf die ich zugreife, um eine boolesche Funktion anzuwenden. das heißt

Vector[Vector[T]], wo ich etwas entlang der Linien von f(myVector(i)(j)) ausführen werde, wo f vom Typ T => Boolean.

Aber das überprüft Grenzen nicht, und ich kann etwas wirklich elegantes nicht bekommen.

kann ich applyOrElse verwenden: myVector.applyOrElse(i, (_:Int) => Vector.empty).applyOrElse (j, (_:Int) => defaultT)

wo f(defaultT)false zurückkehren würde, aber ich wünschte, ich nur einen Standardwert statt einer Funktion einstellen könnte.

I Lift benutzen könnte mir ein Option zu geben, aber sie besteht nicht gut auf der zweiten Ebene: myVector.lift(i) map (_.lift(j) map f getOrElse false) getOrElse false

Welche Arbeit leistet, aber immer noch sehr schwer zu lesen ist.

Und dann gibt es Standard-if/else Blöcke:

if (myVector.size <= i) false 
else { 
    val myVector2 = levelVector(i) 
    if (myVector2.size <= j) false 
    else f(myVector2(j)) 
} 

Es scheint nur, wie etwas, das in der Lage sein sollte, zerlegt werden leichter als das, was ich erreichen kann. Und wenn ich eine dritte Ebene hinzufüge, wird es noch hässlicher.

Gibt es andere Optionen?

Haftungsausschluss: Diese von Coursera des progfun natürlich angepasst ist

Answer 1

Nehmen Sie den folgenden Code aus der Frage:

myVector.lift(i) map (_.lift(j) map f getOrElse false) getOrElse false 

Diese überschrieben werden können wie folgt:

myVector.lift(i).flatMap(_.lift(j)).fold(false)(f) 

Oder vor fold in Scala 2.10 eingeführt wurde:

myVector.lift(i).flatMap(_.lift(j)).map(f).getOrElse(false) 

Die Schlüsselidee besteht darin, das Auspacken (oder Mapping) des Option für wie lo zu verzögern so weit wie möglich. Dieser Ansatz wird sich ganz natürlich auf mehr als zwei Dimensionen erstrecken.

Das ist ziemlich nah an das entspricht dem for einen Sachverhalt in Ihrer Antwort (vorausgesetzt, Sie lift dort einschließen soll), aber wenn man das Verständnis in Klammern zu wickeln habe ich persönlich tendiere die entzuckert Version klarer zu finden.

Answer 2

Ich habe bezifferten etwas, das elegant scheint, auch wenn es ein bisschen übertrieben zu sein scheint:

(for { 
    myVector2 <- myVector(i) 
    t <- myVector2(j) 
} yield t) map f getOrElse false 

Ist das sinnvoll? Es ist sicherlich lesbar. Ist es langsam?