scala.util.parsing.combinator1
trait ImplicitConversions

[source: `scala/util/parsing/combinator1/ImplicitConversions.scala`]

`` `trait` ImplicitConversions
  `extends` AnyRef

  This object contains implicit conversions that come in handy when using the `^^' combinator {@see 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, e.g., parsing something of the following shape: p ~ opt("." ~ repsep(p, ".")) -- where `p' is a parser that yields an A)

Author
  Martin Odersky, Iulian Dragos, Adriaan Moors

Method Summary
`implicit def` | flatten2 [A, B, C](f : (A, B) => C) : (~[A, B]) => C
`implicit def` | flatten3 [A, B, C, D](f : (A, B, C) => D) : (~[~[A, B], C]) => D
`implicit def` | flatten4 [A, B, C, D, E](f : (A, B, C, D) => E) : (~[~[~[A, B], C], D]) => E
`implicit def` | flatten5 [A, B, C, D, E, F](f : (A, B, C, D, E) => F) : (~[~[~[~[A, B], C], D], E]) => F
`implicit def` | headOptionTailToFunList [A, T](f : (List[A]) => T) : (~[A, Option[List[A]]]) => T

Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Method Details

`implicit` `def` flatten2[A, B, C](f : (A, B) => C) : (~[A, B]) => C

`implicit` `def` flatten3[A, B, C, D](f : (A, B, C) => D) : (~[~[A, B], C]) => D

`implicit` `def` flatten4[A, B, C, D, E](f : (A, B, C, D) => E) : (~[~[~[A, B], C], D]) => E

`implicit` `def` flatten5[A, B, C, D, E, F](f : (A, B, C, D, E) => F) : (~[~[~[~[A, B], C], D], E]) => F

`implicit` `def` headOptionTailToFunList[A, T](f : (List[A]) => T) : (~[A, Option[List[A]]]) => T