SimpleExprParser

Instance Constructors

new SimpleExprParser()

Type Members

type Elem = Char

Definition Classes
RegexParsers → Parsers
case class Error extends NoSuccess with Product with Serializable

Definition Classes
Parsers
case class Failure extends NoSuccess with Product with Serializable

Definition Classes
Parsers
type Input = Reader[Elem]

Definition Classes
Parsers
sealed abstract class NoSuccess extends ParseResult[Nothing]

Definition Classes
Parsers
trait OnceParser[+T] extends Parser[T]

Definition Classes
Parsers
sealed abstract class ParseResult[+T] extends AnyRef

Definition Classes
Parsers
abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

Definition Classes
Parsers
case class Success[+T] extends ParseResult[T] with Product with Serializable

Definition Classes
Parsers
case class ~[+a, +b] extends Product with Serializable

Definition Classes
Parsers

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object NoSuccess

Definition Classes
Parsers
def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

Definition Classes
Parsers
def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

Definition Classes
Parsers
def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
implicit def accept(e: Elem): Parser[Elem]

Definition Classes
Parsers
def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

Definition Classes
Parsers
def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
def accessors: Parser[List[P]]

Definition Classes
ExprParser
def afloat: Parser[String]

Definition Classes
ExprParser
def afunc: Parser[Expr]

Definition Classes
ExprParser
def aident: Parser[AExprIdent]

Definition Classes
ExprParser
def aidentExpr: Parser[AExprIdent]

Definition Classes
ExprParser
def aidentaccess: Parser[AExprIdent]

Definition Classes
ExprParser
def aint: Parser[String]

Definition Classes
ExprParser
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attrs: Parser[List[P]]

optional attributes
optional attributes

Definition Classes
ExprParser
def bConst: Parser[BoolExpr]

true or false constants
true or false constants

Definition Classes
ExprParser
def bfactor1: Parser[BoolExpr]

Definition Classes
ExprParser
def bfactor2: Parser[BoolExpr]

Definition Classes
ExprParser
def boolConst: Parser[Expr]

Definition Classes
ExprParser
def bterm1: Parser[BoolExpr]

Definition Classes
ExprParser
def bvalue: Parser[BoolExpr]

single value expressions, where != 0 is true and != null is true
single value expressions, where != 0 is true and != null is true

Definition Classes
ExprParser
def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

Definition Classes
Parsers
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def commit[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def cond: Parser[BoolExpr]

Definition Classes
ExprParser
def df: Parser[BoolExpr]

Definition Classes
ExprParser
def eblock: Parser[Expr]

Definition Classes
ExprParser
def elem(e: Elem): Parser[Elem]

Definition Classes
Parsers
def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

Definition Classes
Parsers
def eq: Parser[BoolExpr]

Definition Classes
ExprParser
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def err(msg: String): Parser[Nothing]

Definition Classes
Parsers
def expr: Parser[Expr]

main entry point for an expression
main entry point for an expression

Definition Classes
ExprParser
def expr2: Parser[Expr]

Definition Classes
ExprParser
def exprAND: Parser[Expr]

Definition Classes
ExprParser
def exprAS: Parser[Expr]

Definition Classes
ExprParser
def exprCMP: Parser[Expr]

Definition Classes
ExprParser
def exprMAP: Parser[Expr]

Definition Classes
ExprParser
def exprMULT: Parser[Expr]

Definition Classes
ExprParser
def exprOR: Parser[Expr]

Definition Classes
ExprParser
def exprPLUS: Parser[Expr]

Definition Classes
ExprParser
def exregex: Parser[Expr]

Definition Classes
ExprParser
def failure(msg: String): Parser[Nothing]

Definition Classes
Parsers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def gt: Parser[BoolExpr]

Definition Classes
ExprParser
def gte: Parser[BoolExpr]

Definition Classes
ExprParser
def guard[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def handleWhiteSpace(source: CharSequence, offset: Int): Int

Attributes
protected
Definition Classes
RegexParsers
def hashCode(): Int

Definition Classes
AnyRef → Any
def ident: Parser[String]

a regular ident but also something in single quotes '[email protected] and - is a good ident eh'
a regular ident but also something in single quotes '[email protected] and - is a good ident eh'

Definition Classes
ExprParser
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def jarray: Parser[Expr]

Definition Classes
ExprParser
def jexpr: Parser[Expr]

Definition Classes
ExprParser
def jnull: Parser[Expr]

Definition Classes
ExprParser
def jnvp: Parser[(String, Expr)]

Definition Classes
ExprParser
def jobj: Parser[Expr]

Definition Classes
ExprParser
def jother: Parser[Expr]

Definition Classes
ExprParser
def jsexpr1: Parser[Expr]

Definition Classes
ExprParser
def jsexpr2: Parser[Expr]

Definition Classes
ExprParser
def jsexpr4: Parser[Expr]

Definition Classes
ExprParser
def jsonIdent: Parser[String]

allow JSON ids with double quotes, single quotes or no quotes
allow JSON ids with double quotes, single quotes or no quotes

Definition Classes
ExprParser
def lambda: Parser[Expr]

Definition Classes
ExprParser
def like: Parser[BoolExpr]

Definition Classes
ExprParser
implicit def literal(s: String): Parser[String]

Definition Classes
RegexParsers
def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

Definition Classes
Parsers
def lt: Parser[BoolExpr]

Definition Classes
ExprParser
def lte: Parser[BoolExpr]

Definition Classes
ExprParser
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
def multilineStrConst: Parser[Expr]

Definition Classes
ExprParser
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def neq: Parser[BoolExpr]

Definition Classes
ExprParser
def not[T](p: ⇒ Parser[T]): Parser[Unit]

Definition Classes
Parsers
def notbfactor1: Parser[BoolExpr]

Definition Classes
ExprParser
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numConst: Parser[Expr]

Definition Classes
ExprParser
def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

Definition Classes
Parsers
def optAttrs: Parser[List[P]]

optional attributes
optional attributes

Definition Classes
ExprParser
def optKinds: Parser[Option[String]]

Definition Classes
ExprParser
def optType: Parser[WType]

:<>type[kind]* <> means it's a ref, not ownership * means it's a list
:<>type[kind]* <> means it's a ref, not ownership * means it's a list

Definition Classes
ExprParser
def orexpr: Parser[BoolExpr]

Definition Classes
ExprParser
def ows: Parser[Option[String]]

Definition Classes
ExprParser
def parse[T](p: Parser[T], in: Reader): ParseResult[T]

Definition Classes
RegexParsers
def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

Definition Classes
RegexParsers
def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Definition Classes
RegexParsers
def parseCond(input: String): Option[BoolExpr]
def parseExpr(input: String): Option[Expr]
def parseIdent(input: String): Option[AExprIdent]
def pasattr: Parser[PAS]

parm assignment, left side can be a[5].name, useful in a $val
parm assignment, left side can be a[5].name, useful in a $val

Definition Classes
ExprParser
def pasattrs: Parser[List[PAS]]

Definition Classes
ExprParser
def pattr: Parser[P]

parm definition / assignment
parm definition / assignment
name:<>type[kind]*~=default
<> means it's a ref, not ownership * means it's a list

Definition Classes
ExprParser
def pcallattr: Parser[P]

Definition Classes
ExprParser
def pcallattrs: Parser[List[P]]

simple ident = expr assignemtn when calling
simple ident = expr assignemtn when calling

Definition Classes
ExprParser
def phrase[T](p: Parser[T]): Parser[T]

Definition Classes
RegexParsers → Parsers
def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

Definition Classes
RegexParsers → Parsers
def pterm1: Parser[Expr]

Definition Classes
ExprParser
def qident: Parser[String]

qualified idents, .
qualified idents, . notation, parsed as a single string

Definition Classes
ExprParser
def qlident: Parser[List[String]]

Definition Classes
ExprParser
def qlidentDiesel: Parser[List[String]]

Definition Classes
ExprParser
def realmqlident: Parser[List[String]]

qualified idents, .
qualified idents, . notation, parsed as a list

Definition Classes
ExprParser
implicit def regex(r: Regex): Parser[String]

Definition Classes
RegexParsers
def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
Annotations
@migration
Migration
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
def scexpr1: Parser[Expr]

Definition Classes
ExprParser
def scexpr2: Parser[Expr]

Definition Classes
ExprParser
def skipWhitespace: Boolean

Definition Classes
RegexParsers
def strConst: Parser[Expr]

Definition Classes
ExprParser
def success[T](v: T): Parser[T]

Definition Classes
Parsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unquote(s: String): String

Definition Classes
ExprParser
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
Definition Classes
RegexParsers
def ws: Regex

Definition Classes
ExprParser
def xpath: Parser[String]

Definition Classes
ExprParser
def xpident: Parser[Expr]

Definition Classes
ExprParser

Related Doc: package expr

class SimpleExprParser extends ExprParser

Instance Constructors

new SimpleExprParser()

Type Members

type Elem = Char

case class Error extends NoSuccess with Product with Serializable

case class Failure extends NoSuccess with Product with Serializable

type Input = Reader[Elem]

sealed abstract class NoSuccess extends ParseResult[Nothing]

trait OnceParser[+T] extends Parser[T]

sealed abstract class ParseResult[+T] extends AnyRef

abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

case class Success[+T] extends ParseResult[T] with Product with Serializable

case class ~[+a, +b] extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object NoSuccess

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 accessors: Parser[List[P]]

def afloat: Parser[String]

def afunc: Parser[Expr]

def aident: Parser[AExprIdent]

def aidentExpr: Parser[AExprIdent]

def aidentaccess: Parser[AExprIdent]

def aint: Parser[String]

final def asInstanceOf[T0]: T0

def attrs: Parser[List[P]]

def bConst: Parser[BoolExpr]

def bfactor1: Parser[BoolExpr]

def bfactor2: Parser[BoolExpr]

def boolConst: Parser[Expr]

def bterm1: Parser[BoolExpr]

def bvalue: Parser[BoolExpr]

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]

def cond: Parser[BoolExpr]

def df: Parser[BoolExpr]

def eblock: Parser[Expr]

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

def eq: Parser[BoolExpr]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

def expr: Parser[Expr]

def expr2: Parser[Expr]

def exprAND: Parser[Expr]

def exprAS: Parser[Expr]

def exprCMP: Parser[Expr]

def exprMAP: Parser[Expr]

def exprMULT: Parser[Expr]

def exprOR: Parser[Expr]

def exprPLUS: Parser[Expr]

def exregex: Parser[Expr]

def failure(msg: String): Parser[Nothing]

def finalize(): Unit

final def getClass(): Class[_]

def gt: Parser[BoolExpr]

def gte: Parser[BoolExpr]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

def ident: Parser[String]

final def isInstanceOf[T0]: Boolean

def jarray: Parser[Expr]

def jexpr: Parser[Expr]