RegexParsers

Type Members

class DisjunctiveParser[A] extends NonTerminalParser[A] with Thunkable

Definition Classes
Parsers
case class LiteralParser(str: String) extends TerminalParser[String] with Product with Serializable

Definition Classes
Parsers
abstract class MappedParser[A, +B] extends Parser[B]

Definition Classes
Parsers
trait NonTerminalParser[+R] extends Parser[R]

Definition Classes
Parsers
sealed trait Parser[+R] extends (LineStream) ⇒ Stream[Result[R]]

Definition Classes
Parsers
case class RegexParser(regex: Regex) extends TerminalParser[String] with Product with Serializable
class RichParser[A] extends AnyRef

Definition Classes
Parsers
class RichRegexParser extends RichParser[String]
class RichSyntax1[A] extends AnyRef

Definition Classes
Parsers
class RichSyntax2[A, B] extends AnyRef

Definition Classes
Parsers
class RichSyntax3l[A, B, C] extends AnyRef

Definition Classes
Parsers
class RichSyntax3r[A, B, C] extends AnyRef

Definition Classes
Parsers
class RichSyntax4ll[A, B, C, D] extends AnyRef

Definition Classes
Parsers
class RichSyntax4lr[A, B, C, D] extends AnyRef

Definition Classes
Parsers
class RichSyntax4rl[A, B, C, D] extends AnyRef

Definition Classes
Parsers
class RichSyntax4rr[A, B, C, D] extends AnyRef

Definition Classes
Parsers
class RichSyntax5lll[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5llr[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5lrl[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5lrr[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5rll[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5rlr[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5rrl[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax5rrr[A, B, C, D, E] extends AnyRef

Definition Classes
Parsers
class RichSyntax6[A, B, C, D, E, F] extends AnyRef

Definition Classes
Parsers
class RichSyntax7[A, B, C, D, E, F, G] extends AnyRef

Definition Classes
Parsers
class RichSyntax8[A, B, C, D, E, F, G, H] extends AnyRef

Definition Classes
Parsers
class SequentialParser[+A, +B] extends NonTerminalParser[~[A, B]]

Definition Classes
Parsers
trait TerminalParser[+R] extends Parser[R]

Definition Classes
Parsers
class Trampoline extends AnyRef

Definition Classes
Parsers

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from RegexParsers to any2stringadd[RegexParsers] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (RegexParsers, B)

Implicit information
This member is added by an implicit conversion from RegexParsers to ArrowAssoc[RegexParsers] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def disjunctiveLiterals(left: String): RichRegexParser

Definition Classes
RegexParsers → Parsers
implicit def disjunctiveRegex(left: Regex): RichRegexParser
implicit def disjunctiveSyntax[A](left: ⇒ Parser[A]): RichParser[A]

Definition Classes
Parsers
def ensuring(cond: (RegexParsers) ⇒ Boolean, msg: ⇒ Any): RegexParsers

Implicit information
This member is added by an implicit conversion from RegexParsers to Ensuring[RegexParsers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (RegexParsers) ⇒ Boolean): RegexParsers

Implicit information
This member is added by an implicit conversion from RegexParsers to Ensuring[RegexParsers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): RegexParsers

Implicit information
This member is added by an implicit conversion from RegexParsers to Ensuring[RegexParsers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): RegexParsers

Implicit information
This member is added by an implicit conversion from RegexParsers to Ensuring[RegexParsers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from RegexParsers to StringFormat[RegexParsers] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
implicit def funLitSyntax(p: String): RichSyntax1[String]

Definition Classes
Parsers
implicit def funRegexSyntax(p: Regex): RichSyntax1[String]
implicit def funSyntax1[A](p: Parser[A]): RichSyntax1[A]

Definition Classes
Parsers
implicit def funSyntax2[A, B](p: Parser[~[A, B]]): RichSyntax2[A, B]

Definition Classes
Parsers
implicit def funSyntax3l[A, B, C](p: Parser[~[~[A, B], C]]): RichSyntax3l[A, B, C]

Definition Classes
Parsers
implicit def funSyntax3r[A, B, C](p: Parser[~[A, ~[B, C]]]): RichSyntax3r[A, B, C]

Definition Classes
Parsers
implicit def funSyntax4ll[A, B, C, D](p: Parser[~[~[~[A, B], C], D]]): RichSyntax4ll[A, B, C, D]

Definition Classes
Parsers
implicit def funSyntax4lr[A, B, C, D](p: Parser[~[~[A, ~[B, C]], D]]): RichSyntax4lr[A, B, C, D]

Definition Classes
Parsers
implicit def funSyntax4rl[A, B, C, D](p: Parser[~[A, ~[~[B, C], D]]]): RichSyntax4rl[A, B, C, D]

Definition Classes
Parsers
implicit def funSyntax4rr[A, B, C, D](p: Parser[~[A, ~[B, ~[C, D]]]]): RichSyntax4rr[A, B, C, D]

Definition Classes
Parsers
implicit def funSyntax5lll[A, B, C, D, E](p: Parser[~[~[~[~[A, B], C], D], E]]): RichSyntax5lll[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5llr[A, B, C, D, E](p: Parser[~[~[~[A, ~[B, C]], D], E]]): RichSyntax5llr[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5lrl[A, B, C, D, E](p: Parser[~[~[A, ~[~[B, C], D]], E]]): RichSyntax5lrl[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5lrr[A, B, C, D, E](p: Parser[~[~[A, ~[B, ~[C, D]]], E]]): RichSyntax5lrr[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5rll[A, B, C, D, E](p: Parser[~[~[A, B], ~[~[C, D], E]]]): RichSyntax5rll[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5rlr[A, B, C, D, E](p: Parser[~[~[A, B], ~[C, ~[D, E]]]]): RichSyntax5rlr[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5rrl[A, B, C, D, E](p: Parser[~[A, ~[B, ~[~[C, D], E]]]]): RichSyntax5rrl[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax5rrr[A, B, C, D, E](p: Parser[~[A, ~[B, ~[C, ~[D, E]]]]]): RichSyntax5rrr[A, B, C, D, E]

Definition Classes
Parsers
implicit def funSyntax6[A, B, C, D, E, F](p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): RichSyntax6[A, B, C, D, E, F]

Definition Classes
Parsers
implicit def funSyntax7[A, B, C, D, E, F, G](p: Parser[~[~[~[~[~[~[A, B], C], D], E], F], G]]): RichSyntax7[A, B, C, D, E, F, G]

Definition Classes
Parsers
implicit def funSyntax8[A, B, C, D, E, F, G, H](p: Parser[~[~[~[~[~[~[~[A, B], C], D], E], F], G], H]]): RichSyntax8[A, B, C, D, E, F, G, H]

Definition Classes
Parsers
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def handleWhitespace(s: LineStream): LineStream

Attributes
protected
Definition Classes
RegexParsers → Parsers
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def literal(str: String): LiteralParser

Definition Classes
RegexParsers → Parsers
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def opt[A](p: Parser[A]): Parser[Option[A]]

Definition Classes
Parsers
implicit def regex(r: Regex): RegexParser
def rep[A](p: Parser[A]): Parser[List[A]]

Definition Classes
Parsers
def rep1[A](p: Parser[A]): Parser[List[A]]

Definition Classes
Parsers
val skipWhitespace: Boolean

Attributes
protected
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
val whitespace: Regex

Attributes
protected
def →[B](y: B): (RegexParsers, B)

Implicit information
This member is added by an implicit conversion from RegexParsers to ArrowAssoc[RegexParsers] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Inherited from Parsers

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from RegexParsers to any2stringadd[RegexParsers]

Inherited by implicit conversion StringFormat from RegexParsers to StringFormat[RegexParsers]

Inherited by implicit conversion Ensuring from RegexParsers to Ensuring[RegexParsers]

Inherited by implicit conversion ArrowAssoc from RegexParsers to ArrowAssoc[RegexParsers]

Ungrouped

Related Docs: object RegexParsers | package gll

trait RegexParsers extends Parsers

Type Members

class DisjunctiveParser[A] extends NonTerminalParser[A] with Thunkable

case class LiteralParser(str: String) extends TerminalParser[String] with Product with Serializable

abstract class MappedParser[A, +B] extends Parser[B]

trait NonTerminalParser[+R] extends Parser[R]

sealed trait Parser[+R] extends (LineStream) ⇒ Stream[Result[R]]

case class RegexParser(regex: Regex) extends TerminalParser[String] with Product with Serializable

class RichParser[A] extends AnyRef

class RichRegexParser extends RichParser[String]

class RichSyntax1[A] extends AnyRef

class RichSyntax2[A, B] extends AnyRef

class RichSyntax3l[A, B, C] extends AnyRef

class RichSyntax3r[A, B, C] extends AnyRef

class RichSyntax4ll[A, B, C, D] extends AnyRef

class RichSyntax4lr[A, B, C, D] extends AnyRef

class RichSyntax4rl[A, B, C, D] extends AnyRef

class RichSyntax4rr[A, B, C, D] extends AnyRef

class RichSyntax5lll[A, B, C, D, E] extends AnyRef

class RichSyntax5llr[A, B, C, D, E] extends AnyRef

class RichSyntax5lrl[A, B, C, D, E] extends AnyRef

class RichSyntax5lrr[A, B, C, D, E] extends AnyRef

class RichSyntax5rll[A, B, C, D, E] extends AnyRef

class RichSyntax5rlr[A, B, C, D, E] extends AnyRef

class RichSyntax5rrl[A, B, C, D, E] extends AnyRef

class RichSyntax5rrr[A, B, C, D, E] extends AnyRef

class RichSyntax6[A, B, C, D, E, F] extends AnyRef

class RichSyntax7[A, B, C, D, E, F, G] extends AnyRef

class RichSyntax8[A, B, C, D, E, F, G, H] extends AnyRef

class SequentialParser[+A, +B] extends NonTerminalParser[~[A, B]]

trait TerminalParser[+R] extends Parser[R]

class Trampoline extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (RegexParsers, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def disjunctiveLiterals(left: String): RichRegexParser

implicit def disjunctiveRegex(left: Regex): RichRegexParser

implicit def disjunctiveSyntax[A](left: ⇒ Parser[A]): RichParser[A]

def ensuring(cond: (RegexParsers) ⇒ Boolean, msg: ⇒ Any): RegexParsers

def ensuring(cond: (RegexParsers) ⇒ Boolean): RegexParsers

def ensuring(cond: Boolean, msg: ⇒ Any): RegexParsers

def ensuring(cond: Boolean): RegexParsers

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

implicit def funLitSyntax(p: String): RichSyntax1[String]

implicit def funRegexSyntax(p: Regex): RichSyntax1[String]

implicit def funSyntax1[A](p: Parser[A]): RichSyntax1[A]

implicit def funSyntax2[A, B](p: Parser[~[A, B]]): RichSyntax2[A, B]

implicit def funSyntax3l[A, B, C](p: Parser[~[~[A, B], C]]): RichSyntax3l[A, B, C]

implicit def funSyntax3r[A, B, C](p: Parser[~[A, ~[B, C]]]): RichSyntax3r[A, B, C]

implicit def funSyntax4ll[A, B, C, D](p: Parser[~[~[~[A, B], C], D]]): RichSyntax4ll[A, B, C, D]

implicit def funSyntax4lr[A, B, C, D](p: Parser[~[~[A, ~[B, C]], D]]): RichSyntax4lr[A, B, C, D]

implicit def funSyntax4rl[A, B, C, D](p: Parser[~[A, ~[~[B, C], D]]]): RichSyntax4rl[A, B, C, D]

implicit def funSyntax4rr[A, B, C, D](p: Parser[~[A, ~[B, ~[C, D]]]]): RichSyntax4rr[A, B, C, D]

implicit def funSyntax5lll[A, B, C, D, E](p: Parser[~[~[~[~[A, B], C], D], E]]): RichSyntax5lll[A, B, C, D, E]

implicit def funSyntax5llr[A, B, C, D, E](p: Parser[~[~[~[A, ~[B, C]], D], E]]): RichSyntax5llr[A, B, C, D, E]

implicit def funSyntax5lrl[A, B, C, D, E](p: Parser[~[~[A, ~[~[B, C], D]], E]]): RichSyntax5lrl[A, B, C, D, E]

implicit def funSyntax5lrr[A, B, C, D, E](p: Parser[~[~[A, ~[B, ~[C, D]]], E]]): RichSyntax5lrr[A, B, C, D, E]

implicit def funSyntax5rll[A, B, C, D, E](p: Parser[~[~[A, B], ~[~[C, D], E]]]): RichSyntax5rll[A, B, C, D, E]

implicit def funSyntax5rlr[A, B, C, D, E](p: Parser[~[~[A, B], ~[C, ~[D, E]]]]): RichSyntax5rlr[A, B, C, D, E]

implicit def funSyntax5rrl[A, B, C, D, E](p: Parser[~[A, ~[B, ~[~[C, D], E]]]]): RichSyntax5rrl[A, B, C, D, E]

implicit def funSyntax5rrr[A, B, C, D, E](p: Parser[~[A, ~[B, ~[C, ~[D, E]]]]]): RichSyntax5rrr[A, B, C, D, E]

implicit def funSyntax6[A, B, C, D, E, F](p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): RichSyntax6[A, B, C, D, E, F]

implicit def funSyntax7[A, B, C, D, E, F, G](p: Parser[~[~[~[~[~[~[A, B], C], D], E], F], G]]): RichSyntax7[A, B, C, D, E, F, G]

implicit def funSyntax8[A, B, C, D, E, F, G, H](p: Parser[~[~[~[~[~[~[~[A, B], C], D], E], F], G], H]]): RichSyntax8[A, B, C, D, E, F, G, H]

final def getClass(): Class[_]

def handleWhitespace(s: LineStream): LineStream

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def literal(str: String): LiteralParser

final def ne(arg0: AnyRef): Boolean