क्या स्कैला में नेस्टेड सेक्स में सीमा से बाहर निकलने का कोई आसान तरीका है?

Question

मुझे वेक्टर का वेक्टर मिला है जिसे मैं एक बूलियन फ़ंक्शन लागू करने के लिए उपयोग कर रहा हूं। अर्थात

Vector[Vector[T]] जहाँ मैं f(myVector(i)(j)) जहां च प्रकार T => Boolean की है की तर्ज पर कुछ अमल करने के लिए जा रहा हूँ।

लेकिन यह सीमाओं की जांच नहीं करता है, और मुझे कुछ वास्तव में सुरुचिपूर्ण नहीं मिल सकता है।

मैं applyOrElse उपयोग कर सकते हैं: myVector.applyOrElse(i, (_:Int) => Vector.empty).applyOrElse (j, (_:Int) => defaultT)

जहां f(defaultT)false वापसी होगी लेकिन काश मैं सिर्फ एक समारोह के बजाय एक डिफ़ॉल्ट मूल्य निर्धारित कर सकते हैं।

मैं लिफ्ट का उपयोग मुझे एक Option देने के लिए कर सकता है, लेकिन यह दूसरे स्तर पर अच्छी तरह से रचना नहीं करता है: myVector.lift(i) map (_.lift(j) map f getOrElse false) getOrElse false

कौन सा काम करता है, लेकिन अभी भी वास्तव में पढ़ने के लिए कठिन है।

और फिर वहाँ मानक है यदि/को अवरोधित कर देते:

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

यह सिर्फ कुछ है कि मैं क्या हासिल कर सकते हैं की तुलना में आसान विघटित किया जा करने के लिए सक्षम होना चाहिए की तरह लगता है। और अगर मैं एक तीसरी परत जोड़ता हूं, तो यह भी उलझन में आता है।

क्या कोई अन्य विकल्प हैं?

अस्वीकरण: इस Coursera के progfun पाठ्यक्रम से अनुकूलित है

Answer 1

सवाल से निम्नलिखित कोड ले लो

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

या, पहले fold स्काला 2.10 में पेश किया गया:

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

मुख्य विचार है कि Option को अवांछित (या मैपिंग) को कम करने के लिए संभव के रूप में एनजी। यह दृष्टिकोण दो से अधिक आयामों के लिए काफी स्वाभाविक रूप से सामान्यीकृत होगा।

यह सुंदर for -comprehension अपने जवाब में (यह मानते हुए तुम वहाँ में lift सम्मिलित करना चाहते थे) के बराबर के करीब है, लेकिन मैं व्यक्तिगत रूप से desugared संस्करण साफ लगता है के लिए करते हैं एक बार आप कोष्ठक में समझ रैप करने के लिए किया है।

Answer 2

मैंने figured कुछ है कि सुंदर लगता है, भले ही यह थोड़ा overkill हो रहा है:

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

इस समझदार है? यह निश्चित रूप से पठनीय है। क्या यह धीमा है? इस प्रकार

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

यह फिर से लिखा जा सकता है::