Scala: Flatten the parseresult (~) from combinators parser into List?

Question

I wrote some parser from combinatory library. I want a generic function that transform any size of nest ~ into a list. How to do this ?

Here is my example of parser I use (my real parser has a very long chain ~ so I want to avoid my current solution which is in comment below).

object CombinatorParser extends RegexParsers {

  lazy val a = "a"
  lazy val b = "b"
  lazy val c = "c"
  lazy val content = a ~ b ~ c // ^^ {case a~b => a::b::c::Nil work but I want something more general that work for any ~ length.
}

object CombinatorTesting {

  def main(args:Array[String]) {
    val testChar = "abc"
    val output = CombinatorParser.parseAll(CombinatorParser.content, testChar)
    println(output) // ((a~b)~c) but I want List(a,b,c)
  }
}

I don't think that's possible. Can't you split your chains into smaller pieces? What exactly are you trying to do? Maybe if you give a little more context someone has a better solution for this. — drexin
– drexin, Commented Mar 7, 2012 at 9:43

Miles Sabin · Accepted Answer · 2012-03-07 12:17:59Z

This is a good (and fairly simple) application for the kind of generic programming techniques exemplified in shapeless.

Given your definition,

object CombinatorParser extends RegexParsers {
  lazy val a = "a"
  lazy val b = "b"
  lazy val c = "c"
  lazy val content = a ~ b ~ c
}

We can recursively define a type class that will flatten it's results as follows,

import CombinatorParser._

First we define a trait which (abstractly) flattens an arbitrary match M to a List[String],

trait Flatten[M] extends (M => List[String]) {
  def apply(m : M) : List[String]
}

Then we provide type class instances for all the shapes of M that we're interested in: in this case, String, A ~ B and ParseResult[T] (where A, B and T are all types for which there are Flatten instances),

// Flatten instance for String
implicit def flattenString = new Flatten[String] {
  def apply(m : String) = List(m) 
}

// Flatten instance for `A ~ B`. Requires Flatten instances for `A` and `B`. 
implicit def flattenPattern[A, B]
  (implicit flattenA : Flatten[A], flattenB : Flatten[B]) =
    new Flatten[A ~ B] {
      def apply(m : A ~ B) = m match {
        case a ~ b => flattenA(a) ::: flattenB(b)
      } 
}

// Flatten instance for ParseResult[T]. Requires a Flatten instance for T.
implicit def flattenParseResult[T]
  (implicit flattenT : Flatten[T]) = new Flatten[ParseResult[T]] {
    def apply(p : ParseResult[T]) = (p map flattenT) getOrElse Nil 
}

Finally we can define a convenience function to simplify applying Flatten instances to parse results,

def flatten[P](p : P)(implicit flatten : Flatten[P]) = flatten(p)

And now we're ready to go,

val testChar = "abc"
val output = parseAll(content, testChar)
println(output)          // ((a~b)~c) but I want List(a, b, c)

val flattenedOutput = flatten(output)
println(flattenedOutput) // List(a, b, c)

rockt · Accepted Answer · 2012-11-15 13:57:14Z

6

If you prefer a solution without generic programming...

  def flatten(res: Any): List[String] = res match {
    case x ~ y => flatten(x) ::: flatten(y)
    case None => Nil
    case Some(x) => flatten(x)
    case x:String => List(x)
  }

  val testChar = "abc"
  val output = CombinatorParser.parseAll(CombinatorParser.content, testChar).getOrElse(None)
  println(flatten(output))

answered Nov 15, 2012 at 13:57

rockt

961 silver badge3 bronze badges

Collectives™ on Stack Overflow

Scala: Flatten the parseresult (~) from combinators parser into List?

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related