[SCALA] 어떻게 패턴 일치 큰 스칼라 케이스 클래스?

어떻게 패턴 일치 큰 스칼라 케이스 클래스?

다음 스칼라 케이스 클래스를 고려 :

case class WideLoad(a: String, b: Int, c: Float, d: ActorRef, e: Date)

패턴 매칭과 같이, 하나 개의 필드 및 폐기 등을 추출 할 날 수 있습니다 :

someVal match {
    case WideLoad(_, _, _, d, _) => d ! SomeMessage(...)
}

무엇 ~ 20 개 홀수 필드를 내가하고 싶은, 그리고 사례 클래스가있을 때 무엇을 더 관련이, WideLoad (교체 아웃 입력을 포함하지 않는 방식으로 단 몇 값을 추출하는 것입니다 _, _, _, _, _, 일부 , _, _, _, 일, _, _), 흥미 롭군요.

나는 다음과 같은 구문이 작동하지 않습니다 있지만라는 이름의 인수는, 여기에 도움이 될 것으로 기대했다 :

someVal match {
    case WideLoad(d = dActor) => dActor ! SomeMessage(...)
    //              ^---------- does not compile
}

많은 _, _, _, _, 희망은 여기에 있는가, 또는 나는 많은 내밀 입력입니까?

편집 : 나는 WideLoad (... 어떤 ...) @ 경우 (WL)을 할 수 있음을 이해 => wl.d, 그러나 나는 아직도 심지어 거기 있는지 궁금하네요 terser 구문 나는 여분의 발을 ​​도입 할 필요없이 필요한 않는 .

해결법

1. ==============================

   1.이 적절한 지 모르겠지만, 당신은 또한 필드 또는 필드의 세트 (테스트되지 않은 코드)에 맞게 단지 객체를 구축 할 수 있습니다 :

   이 적절한 지 모르겠지만, 당신은 또한 필드 또는 필드의 세트 (테스트되지 않은 코드)에 맞게 단지 객체를 구축 할 수 있습니다 :

   object WideLoadActorRef {
     def unapply(wl: WideLoad): Option[ActorRef] = { Some(wl.d) }
   }
   
   someVal match {
     case WideLoadActorRef(d) => d ! someMessage
   }
   

   또는

   object WideLoadBnD {
     def unapplySeq(wl: WideLoad): Option[(Int,ActorRef)] = { Some((wl.b,wl.d)) }
   }
   
   someVal match {
     case WideLoadBnD(b, d) => d ! SomeMessage(b)
   }
   

2. ==============================

   2.당신은 항상 가드로 다시 떨어질 수있다. 정말 좋은,하지만 몬스터의 경우 클래스에 대한 일반적인 패턴 매칭보다 더 나은 아니다 - P

   당신은 항상 가드로 다시 떨어질 수있다. 정말 좋은,하지만 몬스터의 경우 클래스에 대한 일반적인 패턴 매칭보다 더 나은 아니다 - P

   case class Foo(a:Int, b:Int, c:String, d:java.util.Date)
   
   def f(foo:Foo) = foo match {
     case fo:Foo if fo.c == "X" => println("found")
     case _ => println("arrgh!")
   }
   
   f(Foo(1,2,"C",new java.util.Date())) //--> arrgh!
   f(Foo(1,2,"X",new java.util.Date())) //--> found
   

   그게 내가 당신의 디자인을 재고해야한다고 생각했다. 아마 당신이 할 수있는 논리적으로 그룹화 경우 클래스, 튜플,리스트, 세트 또는지도를 사용하여 몇 가지 매개 변수를 설정합니다. 스칼라 지원 중첩 패턴 매칭을 수행합니다

   case class Bar(a: Int, b:String)
   case class Baz(c:java.util.Date, d:String)
   case class Foo(bar:Bar, baz:Baz)
   
   def f(foo:Foo) = foo match {
      case Foo(Bar(1,_),Baz(_,"X")) => println("found")
      case _ => println("arrgh!")
   }
   
   f(Foo(Bar(1,"c"),Baz(new java.util.Date, "X"))) //--> found
   f(Foo(Bar(1,"c"),Baz(new java.util.Date, "Y"))) //--> arrgh! 
   

3. ==============================

   3.당신은 일치하는 패턴 유형을 지정할 수 있습니다 :

   당신은 일치하는 패턴 유형을 지정할 수 있습니다 :

   case class WideLoad(a: String, b: Int, c: Float, d: ActorRef, e: Date)
   
   val someVal = WideLoad(...)
   
   someVal match {
       case w: WideLoad => w.d ! SomeMessage(...)
   }
   

4. ==============================

   4.당신은 당신의 더 큰 경우 클래스의 요약 새로운 케이스 클래스를 만들 수 있습니다

   당신은 당신의 더 큰 경우 클래스의 요약 새로운 케이스 클래스를 만들 수 있습니다

   case class WideLoad(a: String, b: Int, c: Float, d: ActorRef, e: Date)
   case class WideLoadSummary(d: ActorRef, e: Date)
   

   그리고 정상적으로 다음 패턴 일치.

   val someVal = WideLoadSummary(wideload.d, wideload.e)
   
   someVal match {
       case WideLoadSummary(d, _) => d ! SomeMessage(...)
   }
   

from https://stackoverflow.com/questions/3474125/how-to-pattern-match-large-scala-case-classes by cc-by-sa and MIT license