इन्फिक्स ऑपरेटर पर स्कैला मैच अपघटन

Question

मैं स्कैला में List एस के कार्यान्वयन को समझने की कोशिश कर रहा हूं। विशेष रूप से मैं, तुम कैसे एक इन्फ़िक्स ऑपरेटर का उपयोग मैच भाव लिख सकते हैं चारों ओर मेरे सिर प्राप्त करने के लिए कोशिश कर रहा हूँ उदाहरण के लिए:

a match { 
    case Nil => "An empty list" 
    case x :: Nil => "A list without a tail" 
    case x :: xs => "A list with a tail" 
} 

कैसे मैच अभिव्यक्ति x :: xs बजाय List(x, xs) होने की अनुमति दी है?

Answer 1

जे कॉनराड का जवाब लगभग सही है। महत्वपूर्ण बात यह है कि कहीं:: नामक एक ऑब्जेक्ट है जो unapply विधि लागू करता है, Option[(A, List[A])] लौटाता है। Thusly:

object :: { 
    def unapply[A](ls: List[A]) = { 
    if (ls.empty) None 
    else Some((ls.head, ls.tail)) 
    } 
} 

// case objects get unapply for free 
case object Nil extends List[Nothing] 

:: और List के मामले में, इस वस्तु तथ्य यह है कि :: एक मामले वर्ग जो List विशेषता प्रदान करता है से बाहर आने के लिए होता। हालांकि, जैसा कि उपर्युक्त उदाहरण दिखाता है, यह में कोई केस क्लास नहीं है।

Answer 2

मुझे विश्वास है कि :: is actually a class (जो सूची का उप-वर्ग है), इसलिए x :: xs अधिकतर List(x, xs) के बराबर है।

आप इसे अन्य केस क्लास के साथ कर सकते हैं जिनमें ऑपरेटर नाम हैं। उदाहरण के लिए:

case class %%%(x: Int, y: Int) 

a match { 
    case x %%% y => x + y 
} 

Answer 3

मिलान अभिव्यक्ति सूची (x, xs) के बजाय x :: xs कैसे होने की अनुमति है? जब एक पैटर्न, एक इन्फ़िक्स आपरेशन जैसे पी सेशन क्ष बराबर को सेशन (पी, क्यू) है के रूप में देखा

:

इस सवाल का जवाब करने के लिए। यही है, infix ऑपरेटर सेशन को कन्स्ट्रक्टर पैटर्न के रूप में माना जाता है।

(स्काला में प्रोग्रामिंग, 1 एड।, पृ। 331)

भी देखें scala case classes questions