SCombinator

Instance Constructors

new SCombinator()

Type Members

case class Error(message: String, index: Int) extends ParseNonSuccess with Product with Serializable

A data constructor in the case parser failed.
A data constructor in the case parser failed. It must not be recovered.
message
the error message
index
the next index
case class Failure(message: String, index: Int) extends ParseNonSuccess with Product with Serializable

A data constructor in the case parser failed.
A data constructor in the case parser failed. It can be recovered by | operator
message
the error message
index
the next index
type P[+T] = Parser[T]

An alias of Parser[T].
sealed abstract class ParseNonSuccess extends ParseResult[Nothing]

An ADT that represent the parse result in the case that the parser failed.
sealed abstract class ParseResult[+T] extends AnyRef

An ADT that represent the parse result.
An ADT that represent the parse result.
T
the type of value
abstract class Parser[+T] extends (Int) ⇒ ParseResult[T]

A Parser is used to parse the input from the outer class instances.
A Parser is used to parse the input from the outer class instances. It returns the result of type T as the ParseResult.
T
the result type
case class Success[+T](semanticValue: T, index: Int) extends ParseResult[T] with Product with Serializable

A data constructor in the case parser succeed.
A data constructor in the case parser succeed.
T
the type of value
semanticValue
the semantic value
index
the next index
case class ~[+A, +B](a: A, b: B) extends Product with Serializable

Abstract Value Members

abstract def root: Parser[R]

The first nonterminal.
The first nonterminal. The parsing starts from the Parser that this method returns.

Concrete Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def $(literal: String): Parser[String]

It is same as string method.
It is same as string method.
def %: Parser[Location]
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def EOF: Parser[String]
final def any: Parser[Char]

Returns a parser that matches any character except EOF.
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def calculateLocations(): Unit

Calculate all the lines and columns correspond with indexed.
Calculate all the lines and columns correspond with indexed. This is called from parse method.

Attributes
protected
def chainl[T](p: Parser[T])(q: Parser[(T, T) ⇒ T]): Parser[T]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def current(index: Int): String

Attributes
protected
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
final def except(char: Char): Parser[String]

Returns a parser that matches one character without char
Returns a parser that matches one character without char
var fatal: Option[Error]

Attributes
protected
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 hashCode(): Int

Definition Classes
AnyRef → Any
var input: String

Attributes
protected
final def isEOF(index: Int): Boolean

Attributes
protected
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val locations: Map[Int, Location]

Attributes
protected
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def not(parser: Parser[Any]): Parser[Any]

Returns a parser that succeeds iff parser fails.
Returns a parser that succeeds iff parser fails.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def parse(input: String): Result[R]
final def parsePartial(input: String): ParseResult[R]
def parserOf[T](function: (Int) ⇒ ParseResult[T]): Parser[T]
final def predict[A](cases: (Char, Parser[A])*): Parser[A]
final def r(literal: Regex): Parser[String]

It is same as regularExpression method.
It is same as regularExpression method.
var recent: Option[Failure]

Attributes
protected
final def regularExpression(literal: Regex): Parser[String]

Returns a parser that matches literal
Returns a parser that matches literal
final def rule[A](body: ⇒ Parser[A]): Parser[A]

Returns a rule parser which argument is a body parser
final def set(seqs: Seq[Char]*): Parser[String]

Rerurns a parser that matches any element of seqs
Rerurns a parser that matches any element of seqs
lazy val space: Parser[String]
final def string(literal: String): Parser[String]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def token(symbol: String): Parser[String]
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( ... )

Related Doc: package scomb

abstract class SCombinator[R] extends AnyRef

Instance Constructors

new SCombinator()

Type Members

case class Error(message: String, index: Int) extends ParseNonSuccess with Product with Serializable

case class Failure(message: String, index: Int) extends ParseNonSuccess with Product with Serializable

type P[+T] = Parser[T]

sealed abstract class ParseNonSuccess extends ParseResult[Nothing]

sealed abstract class ParseResult[+T] extends AnyRef

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

case class Success[+T](semanticValue: T, index: Int) extends ParseResult[T] with Product with Serializable

case class ~[+A, +B](a: A, b: B) extends Product with Serializable

Abstract Value Members

abstract def root: Parser[R]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def $(literal: String): Parser[String]

def %: Parser[Location]

final def ==(arg0: Any): Boolean

def EOF: Parser[String]

final def any: Parser[Char]

final def asInstanceOf[T0]: T0

final def calculateLocations(): Unit

def chainl[T](p: Parser[T])(q: Parser[(T, T) ⇒ T]): Parser[T]

def clone(): AnyRef

final def current(index: Int): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def except(char: Char): Parser[String]

var fatal: Option[Error]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

var input: String

final def isEOF(index: Int): Boolean

final def isInstanceOf[T0]: Boolean

val locations: Map[Int, Location]

final def ne(arg0: AnyRef): Boolean

final def not(parser: Parser[Any]): Parser[Any]

final def notify(): Unit

final def notifyAll(): Unit

final def parse(input: String): Result[R]

final def parsePartial(input: String): ParseResult[R]

def parserOf[T](function: (Int) ⇒ ParseResult[T]): Parser[T]

final def predict[A](cases: (Char, Parser[A])*): Parser[A]

final def r(literal: Regex): Parser[String]

var recent: Option[Failure]

final def regularExpression(literal: Regex): Parser[String]

final def rule[A](body: ⇒ Parser[A]): Parser[A]

final def set(seqs: Seq[Char]*): Parser[String]

lazy val space: Parser[String]

final def string(literal: String): Parser[String]

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

def toString(): String

def token(symbol: String): Parser[String]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped