Type Members
-
type
Elem
= Char
-
type
Input
= Reader[Elem]
-
type
_$4
-
type
_$4
-
type
_$4
-
type
_$5
-
type
_$5
-
type
_$5
-
type
_$6
-
type
_$6
-
type
_$6
-
type
_$7
-
type
_$7
-
type
_$7
-
type
_$8
-
type
_$8
-
type
_$8
-
type
_$9
-
type
_$9
-
type
_$9
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
##
(): Int
-
def
==
(arg0: AnyRef): Boolean
-
def
==
(arg0: Any): Boolean
-
def
OnceParser
[T]
(f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]
-
def
Parser
[T]
(f: (Input) ⇒ ParseResult[T]): Parser[T]
-
def
accept
[U]
(expected: String, f: PartialFunction[Elem, U]): Parser[U]
-
def
accept
[ES]
(es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]
-
implicit def
accept
(e: Elem): Parser[Elem]
-
def
acceptIf
(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]
-
def
acceptMatch
[U]
(expected: String, f: PartialFunction[Elem, U]): Parser[U]
-
def
acceptSeq
[ES]
(es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]
-
def
any
: PackratParser[Char]
-
implicit def
arbAsgn
: Arbitrary[Asgn]
-
implicit def
arbExp
: Arbitrary[Exp]
-
implicit def
arbNum
: Arbitrary[Num]
-
implicit def
arbSeqn
: Arbitrary[Seqn]
-
implicit def
arbStmt
: Arbitrary[Stmt]
-
implicit def
arbWhile
: Arbitrary[While]
-
def
asInstanceOf
[T0]
: T0
-
lazy val
asgnStmt
: Parser[Asgn]
-
def
chainl1
[T, U]
(first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]
-
def
chainl1
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]
-
def
chainr1
[T, U]
(p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]
-
def
clone
(): AnyRef
-
def
commit
[T]
(p: ⇒ Parser[T]): Parser[T]
-
implicit def
constToTupleFunction2
[A, B, R]
(r: (A, B) ⇒ R): (~[A, B]) ⇒ R
-
implicit def
constToTupleFunction3
[A, B, C, R]
(r: (A, B, C) ⇒ R): (~[~[A, B], C]) ⇒ R
-
implicit def
constToTupleFunction4
[A, B, C, D, R]
(r: (A, B, C, D) ⇒ R): (~[~[~[A, B], C], D]) ⇒ R
-
implicit def
constToTupleFunction5
[A, B, C, D, E, R]
(r: (A, B, C, D, E) ⇒ R): (~[~[~[~[A, B], C], D], E]) ⇒ R
-
implicit def
constToTupleFunction6
[A, B, C, D, E, F, R]
(r: (A, B, C, D, E, F) ⇒ R): (~[~[~[~[~[A, B], C], D], E], F]) ⇒ R
-
lazy val
constrainedInt
: PackratParser[Int]
-
lazy val
double
: Parser[Num]
-
def
elem
(e: Elem): Parser[Elem]
-
def
elem
(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]
-
def
eq
(arg0: AnyRef): Boolean
-
def
equals
(arg0: Any): Boolean
-
def
err
(msg: String): Parser[Nothing]
-
lazy val
exp
: PackratParser[Exp]
-
lazy val
factor
: PackratParser[Exp]
-
def
failure
(msg: String): Parser[Nothing]
-
def
finalize
(): Unit
-
def
genAdd
(sz: Int): Gen[Add]
-
def
genAsgn
(sz: Int): Gen[Asgn]
-
def
genDiv
(sz: Int): Gen[Div]
-
val
genDouble
: Gen[Num]
-
def
genExp
(sz: Int): Gen[Exp]
-
val
genIdn
: Gen[String]
-
val
genInteger
: Gen[Num]
-
def
genInternalExp
(sz: Int): Gen[Binary with Serializable]
-
def
genInternalStmt
(sz: Int): Gen[Stmt]
-
val
genLeafExp
: Gen[Exp with Serializable]
-
val
genLeafStmt
: Gen[Null]
-
def
genMul
(sz: Int): Gen[Mul]
-
def
genNeg
(sz: Int): Gen[Neg]
-
val
genNum
: Gen[Num]
-
def
genSeqn
(sz: Int): Gen[Seqn]
-
def
genStmt
(sz: Int): Gen[Stmt]
-
def
genSub
(sz: Int): Gen[Sub]
-
val
genVar
: Gen[Var]
-
def
genWhile
(sz: Int): Gen[While]
-
def
getClass
(): java.lang.Class[_]
-
def
guard
[T]
(p: ⇒ Parser[T]): Parser[T]
-
def
handleWhiteSpace
(source: CharSequence, offset: Int): Int
-
def
hashCode
(): Int
-
lazy val
idn
: Parser[String]
-
lazy val
integer
: Parser[Num]
-
def
isInstanceOf
[T0]
: Boolean
-
lazy val
keyword
: String
-
var
lastNoSuccess
: NoSuccess
-
implicit def
literal
(s: String): Parser[String]
-
def
log
[T]
(p: ⇒ Parser[T])(name: String): Parser[T]
-
def
memo
[T]
(p: Parser[T]): PackratParser[T]
-
def
mkList
[T]
: (~[T, List[T]]) ⇒ List[T]
-
def
ne
(arg0: AnyRef): Boolean
-
def
not
[T]
(p: ⇒ Parser[T]): Parser[Unit]
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
def
opt
[T]
(p: ⇒ Parser[T]): Parser[Option[T]]
-
def
parse
[T]
(p: Parser[T], in: Reader): ParseResult[T]
-
def
parse
[T]
(p: Parser[T], in: CharSequence): ParseResult[T]
-
def
parse
[T]
(p: Parser[T], in: Reader[Char]): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: CharSequence): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: Reader): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: Reader[Char]): ParseResult[T]
-
implicit def
parseResultToTuple2
[A, B]
(p: Parser[~[A, B]]): PackratParser[(A, B)]
-
implicit def
parseResultToTuple3
[A, B, C]
(p: Parser[~[~[A, B], C]]): PackratParser[(A, B, C)]
-
implicit def
parseResultToTuple4
[A, B, C, D]
(p: Parser[~[~[~[A, B], C], D]]): PackratParser[(A, B, C, D)]
-
implicit def
parseResultToTuple5
[A, B, C, D, E]
(p: Parser[~[~[~[~[A, B], C], D], E]]): PackratParser[(A, B, C, D, E)]
-
implicit def
parseResultToTuple6
[A, B, C, D, E, F]
(p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): PackratParser[(A, B, C, D, E, F)]
-
implicit def
parser2packrat
[T]
(p: ⇒ Parser[T]): PackratParser[T]
-
def
phrase
[T]
(p: Parser[T]): PackratParser[T]
-
def
positioned
[T <: Positional]
(p: ⇒ Parser[T]): Parser[T]
-
implicit def
regex
(r: Regex): Parser[String]
-
def
rep
[T]
(p: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1
[T]
(first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1
[T]
(p: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1sep
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]
-
def
repN
[T]
(num: Int, p: ⇒ Parser[T]): Parser[List[T]]
-
def
repsep
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]
-
def
result
[T]
(v: ⇒ T): Parser[T]
-
lazy val
sequence
: Parser[Seqn]
-
def
skipWhitespace
: Boolean
-
lazy val
start
: PackratParser[Stmt]
-
lazy val
stmt
: PackratParser[Stmt]
-
def
stringToInt
(s: String): Either[Int, String]
-
def
success
[T]
(v: T): Parser[T]
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
lazy val
term
: PackratParser[Exp]
-
def
toString
(): String
-
lazy val
variable
: Parser[Var]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
lazy val
whileStmt
: Parser[While]
-
val
whiteSpace
: Regex
-
def
wrap
[T, U]
(p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]
Inherited from ParserUtilities
Inherited from PackratParsers
Inherited from RegexParsers
Inherited from Parsers
Inherited from AnyRef
Inherited from Any
Basis for tests using the imperative language. Includes support for generating random AST instances plus convenient access to the parser and pretty-printer.