স্কালায় একাধিক কেস ক্লাস মেলে

Question 1

আমি কয়েকটি কেস ক্লাসের সাথে মিলে যাচ্ছি এবং দুটি ক্ষেত্রে একইভাবে পরিচালনা করতে চাই। এটার মতো কিছু:

abstract class Foo
case class A extends Foo
case class B(s:String) extends Foo
case class C(s:String) extends Foo


def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(sb) | C(sc) => "B"
    case _ => "default"
  }
}

তবে আমি যখন এটি করি তখন ত্রুটিটি পাই:

(fragment of test.scala):10: error: illegal variable in pattern alternative
    case B(sb) | C(sc) => "B"

আমি এটিকে কাজ করে নিতে পারি আমি বি এবং সি এর সংজ্ঞা থেকে পরামিতিগুলি সরিয়ে ফেলি তবে কীভাবে আমি প্যারামগুলির সাথে মেলে পারি?

Question 2

দেখে মনে হচ্ছে আপনি স্ট্রিং প্যারামিটারগুলির মানগুলির যত্ন নিচ্ছেন না, এবং বি এবং সি একই আচরণ করতে চান, তাই:

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(_) | C(_) => "B"
    case _ => "default"
  }
}

আপনার যদি অবশ্যই, অবশ্যই, অবশ্যই প্যারামিটারটি বের করতে হবে এবং তাদের সাথে একই কোড ব্লকে চিকিত্সা করতে হবে:

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case bOrC @ (B(_) | C(_)) => {
      val s = bOrC.asInstanceOf[{def s: String}].s // ugly, ugly
      "B(" + s + ")"
    }
    case _ => "default"
  }
}

যদিও আমি অনুভব করি যে এটি কোনও পদ্ধতির মধ্যে ফ্যাক্ট করা অনেক পরিষ্কার er

def doB(s: String) = { "B(" + s + ")" }

def matcher(l: Foo): String = {
  l match {
    case A() => "A"
    case B(s) => doB(s)
    case C(s) => doB(s)
    case _ => "default"
  }
}

Question 3

বেশ কয়েকটি উপায় আছে যা আমি দেখতে পাচ্ছি যে আপনি পরে কী করছেন তা অর্জন করতে, যদি আপনার কেস ক্লাসগুলির মধ্যে কিছু সাধারণতা থাকে। প্রথমত কেস ক্লাসগুলি এমন একটি বৈশিষ্ট্য প্রসারিত করে যা সাধারণতা ঘোষণা করে, দ্বিতীয়টি একটি কাঠামোগত ধরণ ব্যবহার করে যা আপনার কেস শ্রেণির প্রসারিত করার প্রয়োজনকে সরিয়ে দেয়।

 object MuliCase {
   abstract class Foo
   case object A extends Foo

   trait SupportsS {val s: String}

   type Stype = Foo {val s: String}

   case class B(s:String) extends Foo
   case class C(s:String) extends Foo

   case class D(s:String) extends Foo with SupportsS
   case class E(s:String) extends Foo with SupportsS

   def matcher1(l: Foo): String = {
     l match {
       case A        => "A"
       case s: Stype => println(s.s); "B"
       case _        => "default"
     }
   }

   def matcher2(l: Foo): String = {
     l match {
       case A            => "A"
       case s: SupportsS => println(s.s); "B"
       case _            => "default"
     }
   }

   def main(args: Array[String]) {
     val a = A
     val b = B("B's s value")
     val c = C("C's s value")

     println(matcher1(a))
     println(matcher1(b))
     println(matcher1(c))

     val d = D("D's s value")
     val e = E("E's s value")

     println(matcher2(d))
     println(matcher2(e))
   }
 }

কাঠামোগত ধরণের পদ্ধতিটি মুছে ফেলার বিষয়ে একটি সতর্কতা উত্পন্ন করে যা বর্তমানে আমি কীভাবে নির্মূল করব তা নিশ্চিত নই।

Question 4

ঠিক আছে, এটি আসলে বোঝায় না, তাই না? বি এবং সি পারস্পরিক একচেটিয়া, সুতরাং sb বা sc আবদ্ধ হয়ে যান, তবে কোনটি জানেন না, তাই কোনটি ব্যবহার করবেন তা সিদ্ধান্ত নিতে আপনার আরও নির্বাচনের যুক্তির প্রয়োজন হবে (প্রদত্ত যে তারা একটি অপশন [স্ট্রিং] তে আবদ্ধ ছিল, না) একটি স্ট্রিং)। সুতরাং এই কিছুই লাভ হয় না:

  l match {
    case A() => "A"
    case B(sb) => "B(" + sb + ")"
    case C(sc) => "C(" + sc + ")"
    case _ => "default"
  }

অথবা এটা:

  l match {
    case A() => "A"
    case _: B => "B"
    case _: C => "C"
    case _ => "default"
  }