सूची उनके प्रकार पर मिलान तत्वों

Question

मैं नीचे एक करने के लिए एक कोड समान है:

def walkTree(list:List[Command]) { 
    list match { 
     case Command1::rest => doSomething(); walkTree(rest) 
     case Command2::rest => doSomethingElse(); walkTree(rest) 
     case Nil => ; 
    } 
} 

मुझे यह भी पता है कि आप विशिष्ट प्रकार पर पैटर्न मैच और एक ही समय में एक चर असाइन कर सकते हैं:

try { 
    ... 
} 
catch { 
    case ioExc:IOException => ioExc.printStackTrace() 
    case exc:Exception => throw new RuntimeException("Oh Noes", e); 
} 

वहाँ नीचे की तरह कुछ में दोनों गठबंधन करने के लिए एक रास्ता है:

def walkTree(list:List[Command]) { 
    list match { 
     case cmd1:Command1::rest => doSomething(); walkTree(rest) 
     case cmd2:Command2::rest => doSomethingElse(); walkTree(rest) 
     case Nil => ; 
    } 
} 

या मैं befo प्रत्येक सूची तत्व निकालने के लिए की जरूरत है फिर मिल रहा है?

Answer 1

हाँ, बस कोष्ठकों इस तरह (नीचे उदाहरण देखें) का उपयोग करें:

def walkTree(list:List[Command]) { 
    list match { 
     case (cmd1:Command1)::rest => doSomething(); walkTree(rest) 
     case (cmd2:Command2)::rest => doSomethingElse(); walkTree(rest) 
     case Nil => ; 
    } 
} 

हालांकि, आप इस के लिए foreach का उपयोग नहीं कर सकते हैं:

scala> List(A(1), B(2), A(3), B(4), A(5)).foreach(_ match { 
    |  case (a:A) => println("a:" + a) 
    |  case (b:B) => println("b:" + b) 
    | }) 
a:A(1) 
b:B(2) 
a:A(3) 
b:B(4) 
a:A(5) 

---

उदाहरण:

scala> case class A(val i: Int); 
defined class A 

scala> case class B(val i: Int); 
defined class B 

scala> def walkTree(list: List[ScalaObject]) { 
    |  list match { 
    |   case (a:A)::rest => println("a:" + a); walkTree(rest); 
    |   case (b:B)::rest => println("b:" + b); walkTree(rest); 
    |   case Nil => ; 
    |  } 
    | } 
walkTree: (list: List[ScalaObject])Unit 

scala> walkTree(List(A(1), B(2), A(3), B(4), A(5))) 
a:A(1) 
b:B(2) 
a:A(3) 
b:B(4) 
a:A(5) 

Answer 2

012 का उपयोग करनाऔर फिर प्रत्येक तत्व पर पैटर्न मिलान मेरे लिए स्पष्ट प्रतीत होता है:

def walkTree(list:List[Command]) { 
    list foreach { 
    _ match { 
     case cmd1:Command1 => doSomething() 
     case cmd2:Command2 => doSomethingElse() 
     case _ => 
    } 
    } 
}