1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
/* __ *\
** ________ ___ / / ___ 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}))
}
|
