3

我一直在解析具有部分的专有文件格式，每个部分都有许多记录。部分可以按任何顺序排列，记录可以按任何顺序排列。顺序并不重要。虽然部分不应重复，但我不能保证。

我一直在使用 parboiled2 使用如下格式生成 AST：

oneOrMore( Section1 | Section2 | Section3 )

每个部分都生成一个案例类。他们不会继承任何导致Seq[Any]

这些部分案例类还包含Seq[T]特定于部分类型的记录。

我想把它Seq[Any]变成一个

case class (section1:Seq[T1], section2:Seq[T2], section3:Seq[T3] )

是否有人对此有聪明且易于阅读的技术，或者我应该制作一些可变集合并使用带有匹配的 foreach ？

当我回到使用 vars 的 foreach 时，我总是觉得我错过了一些 Scala 魔法。

编辑1：有人提出我应该扩展一个公共基类，我确实可以。match但是如果我仍然必须使用来识别类型，我看不出解决方案有什么变化。我想分离出不同的案例类类型，例如下面我想将所有的B's, C' Es 和F's 一起收集到一个Seq[B], Seq[C],Seq[E]和Seq[F]

 class A()
 case class B(v:Int) extends A
 case class C(v:String) extends A

 case class E(v:Int)
 case class F(v:String)

 val a:Seq[A] = B(1) :: C("2") :: Nil
 val d:Seq[Any] = E(3) :: F("4") :: Nil

 a.head match {
   case B(v) => v should equal (1)
   case _ => fail()
 }

 a.last match {
   case C(v) => v should equal ("2")
   case _ => fail()
 }

 d.head match {
   case E(v) => v should equal (3)
   case _ => fail()
 }

 d.last match {
   case F(v) => v should equal ("4")
   case _ => fail()
 }

编辑 2：折叠解决方案

  case class E(v:Int)
  case class F(v:String)


  val d:Seq[Any] = E(3) :: F("4") :: Nil

  val Ts = d.foldLeft((Seq[E](), Seq[F]()))(
    (c,r) => r match {
      case e:E => c.copy(_1=c._1 :+ e)
      case e:F => c.copy(_2=c._2 :+ e)
    }
  )

  Ts should equal ( (E(3) :: Nil,  F("4") :: Nil) )

编辑 3：穷举

  sealed trait A //sealed is important
  case class E(v:Int) extends A
  case class F(v:String) extends A


  val d:Seq[Any] = E(3) :: F("4") :: Nil

  val Ts = d.foldLeft((Seq[E](), Seq[F]()))(
    (c,r) => r match {
      case e:E => c.copy(_1=c._1 :+ e)
      case e:F => c.copy(_2=c._2 :+ e)
    }
  )

  Ts should equal ( (E(3) :: Nil,  F("4") :: Nil) )
4

1 回答 1

0

虽然这可以通过 shapeless 来制作更简洁的解决方案（正如 Travis指出的那样），但我根据 Travis 的反馈选择了纯 Scala 解决方案。

这是一个使用 foldLeft 来操作包含强类型的元组的示例Seq[]。不幸的是，每种可能的类型都需要在匹配中使用一个 case，如果有很多类型，这可能会变得乏味。

另请注意，如果基类是密封的，则匹配将在丢失类型的情况下发出详尽警告，从而使此操作类型安全。

  sealed trait A //sealed is important
  case class E(v:Int) extends A
  case class F(v:String) extends A


  val d:Seq[A] = E(3) :: F("4") :: Nil

  val Ts = d.foldLeft((Seq[E](), Seq[F]()))(
    (c,r) => r match {
      case e:E => c.copy(_1=c._1 :+ e)
      case e:F => c.copy(_2=c._2 :+ e)
    }
  )

  Ts should equal ( (E(3) :: Nil,  F("4") :: Nil) )
于 2016-05-04T23:09:50.023 回答