/* __ *\ ** ________ ___ / / ___ Scala API ** ** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL ** ** __\ \/ /__/ __ |/ /__/ __ | ** ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ package scala.util.parsing.combinator import scala.language.implicitConversions /** This object contains implicit conversions that come in handy when using the `^^` combinator. * * Refer to [[scala.util.parsing.combinator.Parsers]] to construct an AST from the concrete syntax. * * The reason for this is that the sequential composition combinator (`~`) combines its constituents * into a ~. When several `~`s are combined, this results in nested `~`s (to the left). * The `flatten*` coercions makes it easy to apply an `n`-argument function to a nested `~` of * depth `n-1` * * The `headOptionTailToFunList` converts a function that takes a `List[A]` to a function that * accepts a `~[A, Option[List[A]]]` (this happens when parsing something of the following * shape: `p ~ opt("." ~ repsep(p, "."))` -- where `p` is a parser that yields an `A`). * * @author Martin Odersky * @author Iulian Dragos * @author Adriaan Moors */ trait ImplicitConversions { self: Parsers => implicit def flatten2[A, B, C] (f: (A, B) => C) = (p: ~[A, B]) => p match {case a ~ b => f(a, b)} implicit def flatten3[A, B, C, D] (f: (A, B, C) => D) = (p: ~[~[A, B], C]) => p match {case a ~ b ~ c => f(a, b, c)} implicit def flatten4[A, B, C, D, E] (f: (A, B, C, D) => E) = (p: ~[~[~[A, B], C], D]) => p match {case a ~ b ~ c ~ d => f(a, b, c, d)} implicit def flatten5[A, B, C, D, E, F](f: (A, B, C, D, E) => F) = (p: ~[~[~[~[A, B], C], D], E]) => p match {case a ~ b ~ c ~ d ~ e=> f(a, b, c, d, e)} implicit def headOptionTailToFunList[A, T] (f: List[A] => T)= (p: ~[A, Option[List[A]]]) => f(p._1 :: (p._2 match { case Some(xs) => xs case None => Nil})) }