स्कैला सूचियों के पास ऑर्डरिंग क्यों नहीं है?

Question

क्या कोई कारण है कि स्कैला में सूचियों के लिए कोई अंतर्निहित आदेश नहीं है?

val lists = List(List(2, 3, 1), List(2, 1, 3)) 
lists.sorted 

error: could not find implicit value for parameter ord: Ordering[List[Int]] 

संपादित

हाँ, मेरे सवाल क्यों नहीं निर्मित आदेश है कि क्षेत्र में पहले से ही परोक्ष है नहीं है। मेरे लिए, यह स्पष्ट प्रतीत होता है कि दूसरी सूची पहले सूची से "कम" होनी चाहिए क्योंकि 0 पर आइटम बराबर हैं और दूसरी सूची में कम आइटम 1 है। मैं सोच रहा था कि शायद यह है कि कोई अच्छा जवाब नहीं है सूचियां दो अलग-अलग आकार हैं।

Answer 1

मुझे लगता है कि यह एक निरीक्षण है। लेक्सिकोग्राफिक ऑर्डरिंग सेक्स पर समझ में आता है। हमें इसे मानक पुस्तकालय में जोड़ना चाहिए।

Answer 2

आपके पास सूचियों की एक सूची है, पूर्णांक की सूची नहीं है। आप जो खो रहे हैं यह निर्धारित करने के लिए एक मानदंड है कि कोई सूची < = दूसरी सूची है या नहीं।

त्रुटि संदेश कहता है: मुझे किसी सूची की सूची किसी अन्य सूची में तुलना करने का कोई तरीका नहीं मिल रहा है, आपको एक स्पष्ट रूप से प्रदान करना चाहिए।

यदि आपका प्रश्न "अन्य सूचियों के खिलाफ अंतर्निहित तुलना विधि क्यों नहीं है", तो यह वही तरीका है।

Answer 3

सूची [इंट] के वर्ग पर एकमात्र वास्तव में समझदार कुल आदेश लेक्सिकोफिकॉजिकल होगा (यानी, सूची के पहले तत्वों की तुलना करें, फिर दूसरा अगर वे बराबर हैं, तो तीसरा अगर सेकंड बराबर है, आदि।)। यह मानक पुस्तकालय द्वारा प्रदान नहीं किया जाता है, शायद इसलिए कि ऐसे कई मामले नहीं हैं जहां इसकी वास्तव में आवश्यकता है। [[]] सूची [X] को ऑर्डर करने के लिए सूची [X] से एक अंतर्निहित रूपांतरण बनाने के लिए पर्याप्त आसान होगा जो इसे कार्यान्वित करेगा, और फिर आप जहां भी इसकी आवश्यकता हो वहां उस रूपांतरण को आयात कर सकते हैं।

Answer 4

आप sortWith का उपयोग कर सकते हैं। इस खाते में सूचियों को अलग ढंग से आकार नहीं ले करता है क्योंकि जिप अंतर बाहर फेंक होगा, लेकिन मैं इसे आप क्या कर रहे हैं के बाद की तरह कुछ करता है लगता है:

lists.sortWith((a,b) => { 
    a.zip(b).filterNot(x => x._1 == x._2) match { 
    case Nil => true 
    case t => t._1 < t._2 
    } 
}) 

Answer 5

संयोग से पहले भी मैं इस तय आप इस अन्य तरीकों से कर सकता है:

scala> List[Iterable[Int]](List(2, 3, 1), List(2, 1, 3)).sorted 
res0: List[Iterable[Int]] = List(List(2, 1, 3), List(2, 3, 1)) 

scala> List(List(2, 3, 1), List(2, 1, 3)).sorted(Ordering[Iterable[Int]]) 
res1: List[List[Int]] = List(List(2, 1, 3), List(2, 3, 1)) 

लेकिन अब यह काम करता है की तरह आप उम्मीद होगी।

संपादित करें: अपेक्षित अंतर्निहितता के साथ स्केची विचलन के मुद्दों के कारण मैंने इसे डिफ़ॉल्ट दायरे से बाहर कर दिया। एक अंतर्निहित रूपांतरण होने के कारण जो इस तरह से बाध्य होता है:

implicit def SeqDerived[CC[X] <: collection.Seq[X], T](implicit ord: Ordering[T]): Ordering[CC[T]] 

... मुद्दों के लिए एक संभावित नुस्खा है। यह 2.9 में उपलब्ध होगा, लेकिन आपको इसे निम्नानुसार आयात करना होगा। यद्यपि आप है कि क्या छोटे सूचियों से बड़ा या लंबे समय तक सूचियों की तुलना में कम कर रहे हैं के रूप में एक विकल्प बनाने की जरूरत है

scala> val lists = List(List(2, 3, 1), List(2, 1, 3)) 
lists: List[List[Int]] = List(List(2, 3, 1), List(2, 1, 3)) 

scala> lists.sorted 
<console>:9: error: could not find implicit value for parameter ord: Ordering[List[Int]] 
     lists.sorted 
      ^

scala> import Ordering.Implicits._ 
import Ordering.Implicits._ 

scala> lists.sorted 
res1: List[List[Int]] = List(List(2, 1, 3), List(2, 3, 1))