एक स्कैला सूची के पैटर्न और सिर के पूंछ प्रकार कैसे पैटर्न?

Question

मैं head और tail के प्रकार पर scala में एक list के विभिन्न खण्डों पर pattern match चाहते हैं:

class Solution07 extends FlatSpec with ShouldMatchers { 
    "plain recursive flatten" should "flatten a list" in { 
    val list1 = List(List(1, 1), 2, List(3, List(5, 8))) 
    val list1Flattened = List(1, 1, 2, 3, 5, 8) 

    flattenRecur(list1) should be (list1Flattened) 
    } 

    def flattenRecur(ls: List[Any]): List[Int] = ls match { 
    case (head: Int) :: (tail: List[Any]) => head :: flattenRecur(tail) 
    case (head: List[Int]) :: (tail: List[Any]) => head.head :: flattenRecur(head.tail :: tail) 
    case (head: List[Any]) :: (tail: List[Any]) => flattenRecur(head) :: flattenRecur(tail) // non-variable type... on this line. 
    } 
} 

मैं:

Error:(18, 17) non-variable type argument Int in type pattern List[Int] (the underlying of List[Int]) is unchecked since it is eliminated by erasure case (head: List[Int]) :: (tail: List[Any]) => head.head :: flattenRecur(head.tail :: tail) ^

मैं क्या याद आ रही है? सूची के लिए head और tail के प्रकार पर पैटर्न मिलान करना मेरे लिए कैसे संभव है?

Answer 1

मैं मानता हूँ कि HList साथ @Andreas समाधान समस्या को हल करने के लिए एक अच्छी मिसाल है, लेकिन मैं अभी भी समझ में नहीं आता इस के साथ समस्या क्या:

def flatten(ls: List[_]): List[Int] = ls match { 
    case Nil => Nil 
    case (a: Int) :: tail => a :: flatten(tail) 
    case (a: List[_]) :: tail => flatten(a) ::: flatten(tail) 
    case _ :: tail => flatten(tail) 
    } 

तब:

println(flatten(List(List("one",9,8),3,"str",4,List(true,77,3.2)))) // List(9, 8, 3, 4, 77) 

मुझे आपके कार्य में टाइप एरर के साथ कोई समस्या नहीं दिख रही है, क्योंकि आपको वास्तव में मिटाए गए प्रकारों का परीक्षण करने की आवश्यकता नहीं है। मैंने जानबूझकर मेरे उदाहरण में सभी मिटाए गए प्रकारों को छोड़ दिया है - इसे दिखाने के लिए। टाइप एरर सूची के तत्वों की प्रकार की जानकारी को साफ़ नहीं करता है, यह केवल मेरे सामान्य मामले में Any या _ है जो सूची जेनेरिक की प्रकार की जानकारी को साफ़ करता है - इसलिए आपको इसकी आवश्यकता नहीं है। अगर मैं कभी याद नहीं कर रहा हूं, तो आपके उदाहरण में प्रकारों को मिटाया नहीं जाता है, क्योंकि आपके पास लगभग हर जगह Any है।

Answer 2

मिराज टाइप करने के कारण आप प्रत्येक तत्व का निरीक्षण कर सकते हैं।

def flattenRecur(ls: List[Any]): List[Int] = ls match { 
    case head :: tail if (head.isInstanceOf[Int]) 
        => head.asInstanceOf[Int] :: flattenRecur(tail) 
    case head :: tail if (head.isInstanceOf[List[Any]]) 
        => flattenRecur(head.asInstanceOf[List[Any]]) ++ 
         flattenRecur(tail) 
    case _ :: tail => flattenRecur(tail) 
    case _ => Nil 
} 

कौन सा दिखाई देता है काम करने के लिए:

scala> flattenRecur(List(List("one",9,8),3,"str",4,List(true,77,3.2))) 
res8: List[Int] = List(9, 8, 3, 4, 77) 

लेकिन अंगूठे का एक सामान्य नियम के रूप में, Any परहेज आम तौर पर प्रयास के लायक है।

Answer 3

आप वस्तु प्रणाली द्वारा दिए गए प्रतिबंध से मारा जाता है:

केवल आम माता-पिता List[Int] और Int के लिए Any

तो कारण है कि अनुमान प्रणाली केवल सुरक्षित रूप से मान सकते हैं कि आप Any लौट सकता है। समाधान प्रस्तावित @jwvh करने योग्य है लेकिन रनटाइम अपवादों का संभावित खतरा है।

आप एक typesafe तरह से समस्या का समाधान चाहते हैं एक विकल्प निराकार पुस्तकालय https://github.com/milessabin/shapeless की HList उपयोग करने के लिए हो सकता है: https://github.com/milessabin/shapeless/wiki/Feature-overview:-shapeless-2.0.0#heterogenous-lists