मैं इस नील केस

Question

को कैसे छोड़ सकता हूं मैं कुछ सामान्य एल्गोरिदम लागू करने वाले स्कैला के साथ मिल रहा हूं। एक बुलबुला तरह मैं इस मुद्दे

में भाग पुनः बनाने का प्रयास करते समय यहाँ शीर्ष करने के लिए मूल्य बुलबुले कि एक आंतरिक पाश के एक कार्यान्वयन है:

def pass(xs:List[Int]):List[Int] = xs match { 
    case Nil => Nil 
    case x::Nil => x::Nil 
    case l::r::xs if(l>r) => r::pass(l::xs) 
    case l::r::xs => l::pass(r::xs) 
} 

मेरे मुद्दा मामले Nil => Nil के साथ है। मैं समझता हूं कि मुझे इसकी आवश्यकता है क्योंकि मैं इस समारोह में Nil लागू कर सकता हूं। क्या यह सुनिश्चित करने का कोई तरीका है कि Nil इस तरह से एक तर्क के रूप में प्रदान नहीं किया जा सकता है जो संकलक को संतुष्ट करेगा ताकि मैं इस मामले को खत्म कर सकूं?

Answer 1

सूची में दो उपप्रकार, शून्य और :: है, इसलिए :: एक सूची का प्रतिनिधित्व करता है जिसमें कम से कम एक तत्व होता है।

def pass(xs: ::[Int]):List[Int] = xs match { 
    case x::Nil => x::Nil 
    case l::r::xs if(l>r) => r::pass(new ::(l,xs)) 
    case l::r::xs => l::pass(new ::(r, xs)) 
} 

Answer 2

यह मूल प्रकार के परिष्करण के अनुरूप होगा, जहां आप एक प्रकार लिखेंगे जिसका सदस्य प्रारंभिक प्रकार का सबसेट था। फिर आप यह दिखाएंगे कि, आपके इनपुट में प्रत्येक इनपुट x के लिए, x गैर Nil था। चूंकि इसके लिए पर्याप्त मात्रा में प्रमाण की आवश्यकता होती है (आप इसे सबसेट प्रकार का उपयोग कर निर्भर प्रकार के साथ कोक में कार्यान्वित कर सकते हैं), इस स्थिति में करने के लिए बेहतर चीज एक नया प्रकार पेश करना हो सकता है, जिसमें Nil कन्स्ट्रक्टर नहीं था , केवल विपक्ष के लिए एक कन्स्ट्रक्टर और एक तत्व।

संपादित करें: स्कैला आपको इसे लागू करने के लिए सूची प्रकार पर उप-प्रकार का उपयोग करने की अनुमति देता है, तो आप इसे उस उप प्रकार का उपयोग करके विधि प्रणाली में साबित कर सकते हैं। यह अभी भी एक सबूत है, इस अर्थ में कि किसी भी प्रकार की जांच इस सबूत से मेल खाती है कि कार्यक्रम वास्तव में कुछ प्रकार में रहता है, यह केवल कुछ ऐसा है जो संकलक पूरी तरह साबित कर सकता है।

Answer 3

उस मामले तो आप बस case खंड के साथ खेल सकते में आदेश:

def pass(xs:List[Int]):List[Int] = xs match { 
    case l::r::xs if(l>r) => r::pass(l::xs) 
    case l::r::xs => l::pass(r::xs) 
    case xs => xs 
} 

पहले दो खंड केवल एक या अधिक तत्वों के साथ सूची से मेल खाएगी। अंतिम खंड कहीं और मिल जाएगा।