Comment puis-je extraire des classes de cas remplies d'options dans Scala

La réponse de Ziggystar est ce que j'utiliserais, mais pour l'exhaustivité, la correspondance des motifs peut également être utilisée, par exemple

val someCash: Option[Cash] = person match {
  case Person(Some(Pants(Some(Pocket(Some(cash)))))) => Some(cash)
  case _ => None
}

La question ne mentionnait pas modifier em> les données, mais lorsque vous devez le faire, vous trouverez rapidement la bibliothèque Scala ne dispose pas des outils pour faciliter la tâche (lorsque les données sont immuables) . Si vous n'avez pas encore vécu cela, essayez d'écrire une fonction qui remplacera ou modifiera la valeur code> du en espèces code> détenu par un personne code> , en utilisant les types définis dans la question.

comme décrit dans Tony Morris ' Objectifs asymétriques à Scala , lentilles em> sont une solution appropriée à ce problème. P>

Voici un exemple de la manière dont nous pouvons accéder à l'accès et à la mise à jour de la valeur code> code> d'une personne en espèces code> à l'aide de la lentille code> et Plens code> (objectif partiel) des implémentations de Scalaz-Seven Branche de Scalaz. P>

Premier, certains chaudières: définir l'instance de lentille pour chaque champ des classes de boîtier. A @ - @ b code> signifie identique à objectif [A, B] code>. p> xxx pré>

Nous ne pouvons pas composer toutes ces lentilles, cependant, parce que la plupart des champs sont enveloppés dans les types code> (code> (code> p>

lentilles partielles em> à la rescousse: celles-ci nous permettent d'accéder à et mettre à jour les parties d'une structure qui peut ne pas exister em>, telle que la valeur une valeur code> d'une option code> ou de la tête ou de la tête code > d'une liste code> code>. p>

Nous pouvons utiliser la fonction code> à pied code> de Scalaz 7 pour créer une lentille partielle visualisant chaque champ facultatif. Afin de composer une lentille partielle avec l'une de nos objectifs ordinaires, nous devons toutefois accéder à l'instance d'objectif partielle équivalente pour la lentille ordinaire, à l'aide de la méthode partielle code> sur chaque lentille .

scala> val ben = Person(None)
ben: Person = Person(None)

scala> someCashValue.mod(_ + ", zero, nada", ben)
res4: Person = Person(None)

Scalaz 7 a changé un peu donc ici est un autre exemple:

  object PartialLensExample extends App {

  import scalaz._
  import Lens._
  import PLens._


  case class Bar(blub: Option[String])
  case class Foo(bar: Option[Bar])

  // normal lenses for getting and setting values
  val fooBarL: Foo @> Option[Bar] = lensg(foo ⇒ bar ⇒ foo.copy(bar = bar), _.bar)
  val barBlubL: Bar @> Option[String] = lensg(bar ⇒ blub ⇒ bar.copy(blub = blub), _.blub)

  // compose the above as 'Partial Lenses', >=> is just an alias for 'andThen'
  val fooBarBlubL: Foo @?> String = fooBarL.partial >=> somePLens >=> barBlubL.partial >=> somePLens

  // try it
  val foo = Foo(Some(Bar(Some("Hi"))))

  println(fooBarBlubL.get(foo)) // Some(Hi)

  println(fooBarBlubL.set(foo, "Bye")) //Foo(Some(Bar(Some(Bye))))

  // setting values
  val foo2 = Foo(None)
  println(fooBarL.set(foo2, Some(Bar(None)))) // Foo(Some(Bar(None)))

}