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
arbExp
: Arbitrary[Exp]
-
implicit def
arbVar
: Arbitrary[Var]
-
def
asInstanceOf
[T0]
: T0
-
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]
-
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
fv
(t: Exp): Set[Idn]
-
def
genAppExp
(sz: Int): Gen[App]
-
def
genExp
(sz: Int): Gen[Exp]
-
val
genIdn
: Gen[String]
-
def
genLamExp
(sz: Int): Gen[Lam]
-
val
genLeafExp
: Gen[Product with Serializable with Exp]
-
val
genNum
: Gen[Num]
-
val
genVar
: Gen[Var]
-
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
: Regex
-
lazy val
integer
: Parser[Num]
-
def
isInstanceOf
[T0]
: Boolean
-
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
-
val
normal
: Strategy
-
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]
-
def
skipWhitespace
: Boolean
-
lazy val
start
: PackratParser[Exp]
-
def
stringToInt
(s: String): Either[Int, String]
-
def
success
[T]
(v: T): Parser[T]
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
toString
(): String
-
lazy val
variable
: Parser[Var]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
val
whiteSpace
: Regex
-
def
wrap
[T, U]
(p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]
-
val
xgc_reduction
: Strategy
Inherited from ParserUtilities
Inherited from PackratParsers
Inherited from RegexParsers
Inherited from Parsers
Inherited from AnyRef
Inherited from Any
Basis for tests using the lambda calculus language. Includes access to the parser, generator and evaluator.