मैं स्कैला

Question

में विकल्प से भरे केस क्लास को कैसे खींचूं मैं स्कैला के लिए बहुत नया हूं और मैं अभी भी वाक्यविन्यास और शैली में उपयोग करने की कोशिश कर रहा हूं, इसलिए यह शायद एक बहुत ही सरल सवाल है।

मैं एक codebase जहां मामले कक्षाएं तो जैसे विकल्पों के साथ आबादी के बहुत देखते हैं के साथ काम कर रहा हूँ:

case class Person(
    pants: Option[Pants] 
) 
case class Pants(
    pocket: Option[Pocket] 
) 
case class Pocket(
    cash: Option[Cash] 
) 
case class Cash(
    value: String = "zilch" 
) 

उपरोक्त उदाहरण में, कैसे आप कितना पैसा लौटने के बारे में जाना होगा एक Person में है ' एस PantsPocket, अगर वे वास्तव में पैंट पहन रहे हैं ... जेब के साथ, और यदि उनके पास कोई पैसा है?

Answer 1

for-comprehensions के लिए एक महान समय:

val someCash: Option[Cash] = 
    for(pants <- somePerson.pants; 
     pocket <- pants.pocket; 
     cash <- pocket.cash) yield cash 

इसके तुल्य आप निम्नलिखित है, जिसके लिए पहले कोड वाक्यात्मक चीनी है (कुछ बारीकियों अनदेखी) लिख सकते हैं:

val someCash: Option[Cash] = 
    somePerson.pants.flatMap(_.pocket.flatMap(_.cash)) 

(मैं नहीं कर रहा हूँ पूरी तरह से सुनिश्चित करें कि अगर आप _ वाइल्डकार्ड का उपयोग करके अंतिम अभिव्यक्ति लिख सकते हैं, जैसा मैंने किया था)।

Answer 2

ziggystar का जवाब मैं क्या प्रयोग करेंगे है, लेकिन पूर्णता के लिए, पैटर्न मिलान भी इस्तेमाल किया जा सकता जैसे,

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

Answer 3

सवाल डेटा को संशोधित जिक्र नहीं किया था, लेकिन आप क्या करने की जरूरत है जब यह आपको जल्दी से स्केल लाइब्रेरी में यह आसान बनाने के लिए टूल नहीं है (जब डेटा अपरिवर्तनीय है)। यदि आपने अभी तक इसका अनुभव नहीं किया है, तो प्रश्न में परिभाषित प्रकारों का उपयोग करके Person द्वारा आयोजित Cash के value को प्रतिस्थापित करने या संशोधित करने वाले फ़ंक्शन को लिखने का प्रयास करें।

टोनी मॉरिस 'Asymmetric Lenses in Scala, लेंस में वर्णित अनुसार इस समस्या का उचित समाधान है।

यहाँ हम कैसे जाएं और Scalaz की scalaz-seven शाखा से एक व्यक्ति के CashLens और PLens (आंशिक लेंस) कार्यान्वयन का उपयोग करने का value अद्यतन कर सकते हैं का एक उदाहरण है।

सबसे पहले, कुछ बॉयलरप्लेट: केस कक्षाओं के प्रत्येक क्षेत्र के लिए लेंस उदाहरण परिभाषित करें। A @-@ B का अर्थ Lens[A, B] जैसा है।

val pants: Person @-@ Option[Pants] = 
    lensG(_.pants, p => ps => p.copy(pants = ps)) 

val pocket: Pants @-@ Option[Pocket] = 
    lensG(_.pocket, ps => p => ps.copy(pocket = p)) 

val cash: Pocket @-@ Option[Cash] = 
    lensG(_.cash, p => c => p.copy(cash = c)) 

val value: Cash @-@ String = 
    lensG(_.value, c => v => c.copy(value = v)) 

हम इन लेंसों के सभी रचना नहीं कर सकते, तथापि, क्योंकि क्षेत्रों के सबसे Option प्रकार में लिपटे रहे हैं।

आंशिक लेंस बचाव के लिए: इन हमें पहुँच सकते हैं और एक संरचना है कि , इस तरह के मौजूद न हो एक Option की Some मूल्य, या एक List की head के रूप में की अद्यतन भागों करने देते हैं।

हम प्रत्येक वैकल्पिक फ़ील्ड को देखने वाले आंशिक लेंस बनाने के लिए स्कालज़ 7 से somePLens फ़ंक्शन का उपयोग कर सकते हैं।हमारे नियमित लेंस में से एक के साथ आंशिक लेंस लिखने के लिए, हमें विधि पर मौजूद partial विधि का उपयोग करके, नियमित लेंस के लिए समकक्ष आंशिक लेंस उदाहरण तक पहुंचने की आवश्यकता है।

// @-? is an infix type alias for PLens 
val someCash: Pocket @-? Cash = cash.partial andThen somePLens 

scala> someCash.get(Pocket(Some(Cash("zilch")))) 
res1: Option[Cash] = Some(Cash(zilch)) 

उसी तरह, हम सब अपने लेंस 'partial उदाहरणों लिखने, और somePLens के उदाहरण sandwiching द्वारा नकद एक Person द्वारा आयोजित देखने हमारे आंशिक लेंस बना सकते हैं। यहां, मैंने <=< ऑपरेटर का उपयोग किया है, andThen के लिए उपनाम (जो ऑपरेटरों के साथ compose के बराबर है)।

scala> someCashValue.get(ben) 
res2: Option[String] = Some(zilch) 

मूल्य को संशोधित करने के आंशिक लेंस का उपयोग करना: मैं नकदी की मूल्य तक पहुँचने के लिए आंशिक लेंस का प्रयोग

val ben = Person(Some(Pants(Some(Pocket(Some(Cash("zilch"))))))) 

:

val someCashValue: Person @-? String = 
    pants.partial <=< somePLens <=< 
    pocket.partial <=< somePLens <=< 
    cash.partial <=< somePLens <=< 
    value.partial 

साथ खेलने के लिए एक Person उदाहरण बनाना :

scala> someCashValue.mod(_ + ", zero, nada", ben) 
res3: Person = Person(Some(Pants(Some(Pocket(Some(Cash(zilch, zero, nada))))))) 

(!) 0

अब, अगर मैं नहीं किसी भी पैंट पहने हुए है, हम देख सकते हैं कि मेरी नकदी की मूल्य को संशोधित करने की कोशिश कोई प्रभाव नहीं पड़ेगा:

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

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

Answer 4

Scalaz 7 एक छोटे से इतना बदल गया है यहां एक और उदाहरण है:

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))) 

}