Parser

Instance Constructors

new Parser()

Abstract Value Members

abstract def apply(index: Int): ParseResult[T]

Parses input from the start index
Parses input from the start index
index
the start index
returns
the parse result, which type is T

Definition Classes
Parser → Function1

Concrete Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def *: Parser[List[T]]

Returns a Parser that represents repetition (0 or more)
def +: Parser[List[T]]

Returns a Parser that represents repetition (1 or more).
Returns a Parser that represents repetition (1 or more). It is same as
```
  (this ~ this.*).map { case hd ~ tl => hd :: tl }
```
def <<[U](rhs: Parser[U]): Parser[T]

Returns a sequential Parser consists of this and rhs.
Returns a sequential Parser consists of this and rhs. Note that the result of rhs is ignored. It is same as
```
  for {
    t <- this
    _ <- rhs
  } yield t
```
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >>[U](rhs: Parser[U]): Parser[U]

Returns a sequential Parser consists of this and rhs.
Returns a sequential Parser consists of this and rhs. Note that the result of this is ignored. It is same as
```
  for {
    _ <- this
    u <- rhs
  } yield u
```
def ?: Parser[Option[T]]

Returns a repetition Parser (0 or 1)
def ^^[U](function: (T) ⇒ U): Parser[U]

It is same as map
It is same as map
def andThen[A](g: (ParseResult[T]) ⇒ A): (Int) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

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

This method is same as withErrorMessage() except for no message being specified.
def compose[A](g: (A) ⇒ Int): (A) ⇒ ParseResult[T]

Definition Classes
Function1
Annotations
@unspecialized()
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def filter(predicate: (T) ⇒ Boolean, message: String = "not matched to predicate"): Parser[T]

Returns a Parser which only succeeds iff predicate(result) is true.
Returns a Parser which only succeeds iff predicate(result) is true.
message
the error message in that predicate(result) is false
def flatMap[U](function: (T) ⇒ Parser[U]): Parser[U]

Returns a parser such that 1.
Returns a parser such that 1. this parses from current position 2. convert the intermediate result of type T to a parser. 3. the parser parses from the next position and returns the result of type U
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def l(newLabel: String): Parser[T]
def labeled(newLabel: String): Parser[T]
def map[U](function: (T) ⇒ U): Parser[U]

Returns a parser that the result is converted from T to U
Returns a parser that the result is converted from T to U
function
the result converter
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def repeat0By(separator: Parser[Any]): Parser[List[T]]

Returns a repetition Parser (0 or more), which separator is separator
Returns a repetition Parser (0 or more), which separator is separator
separator
this parses separator, which result is ignored
def repeat1By(separator: Parser[Any]): Parser[List[T]]

Returns a repetition Parser (1 or more), which separator is separator
Returns a repetition Parser (1 or more), which separator is separator
separator
this parses separator, which result is ignored
def replace(message: String): Parser[T]

Return the same parser except it replace the failure message with message
Return the same parser except it replace the failure message with message
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Function1 → AnyRef → Any
final def wait(arg0: Long, arg1: Int): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def withErrorMessage(message: String): Parser[T]

Replace the failure parser with the error parser.
Replace the failure parser with the error parser. It is used to suppress backtracks.
message
the error message
def withFilter(predicate: (T) ⇒ Boolean): Parser[T]

It is same as filter
It is same as filter
def |[U >: T](rhs: Parser[U]): Parser[U]

Returns an alternation Parser.
Returns an alternation Parser. It first trys this. It trys rhs iff this failed.
U
the result type of rhs
rhs
the alternation
def |||[U >: T](rhs: Parser[U]): Parser[U]

Returns a alternation parser.
Returns a alternation parser. It selects longest match.
def |~[U >: T](rhs: Parser[U], catchLabels: String*): Parser[U]

Returns an alternation parser.
Returns an alternation parser. It first trys this. It trys <cdde>rhs> iff this failed and parameters are appropriate catchLabels.
def ~[U](right: Parser[U]): Parser[~[T, U]]

Returns a sequential Parser consists of this and rhs.
Returns a sequential Parser consists of this and rhs.
def ~<[U](rhs: Parser[U]): Parser[T]

This method is same as << method.
This method is same as << method. The only difference is operator precedence.
def ~>[U](rhs: Parser[U]): Parser[U]

This method is same as >> method.
This method is same as >> method. The only difference is operator precedence.

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Doc: package SCombinator

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

Instance Constructors

new Parser()

Abstract Value Members

abstract def apply(index: Int): ParseResult[T]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def *: Parser[List[T]]

def +: Parser[List[T]]

def <<[U](rhs: Parser[U]): Parser[T]

final def ==(arg0: Any): Boolean

def >>[U](rhs: Parser[U]): Parser[U]

def ?: Parser[Option[T]]

def ^^[U](function: (T) ⇒ U): Parser[U]

def andThen[A](g: (ParseResult[T]) ⇒ A): (Int) ⇒ A

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def commit: Parser[T]

def compose[A](g: (A) ⇒ Int): (A) ⇒ ParseResult[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(predicate: (T) ⇒ Boolean, message: String = "not matched to predicate"): Parser[T]

def flatMap[U](function: (T) ⇒ Parser[U]): Parser[U]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def l(newLabel: String): Parser[T]

def labeled(newLabel: String): Parser[T]

def map[U](function: (T) ⇒ U): Parser[U]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def repeat0By(separator: Parser[Any]): Parser[List[T]]

def repeat1By(separator: Parser[Any]): Parser[List[T]]

def replace(message: String): Parser[T]

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

def toString(): String

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def withErrorMessage(message: String): Parser[T]

def withFilter(predicate: (T) ⇒ Boolean): Parser[T]

def |[U >: T](rhs: Parser[U]): Parser[U]

def |||[U >: T](rhs: Parser[U]): Parser[U]

def |~[U >: T](rhs: Parser[U], catchLabels: String*): Parser[U]

def ~[U](right: Parser[U]): Parser[~[T, U]]

def ~<[U](rhs: Parser[U]): Parser[T]

def ~>[U](rhs: Parser[U]): Parser[U]

Deprecated Value Members

def finalize(): Unit

Inherited from (Int) ⇒ ParseResult[T]

Inherited from AnyRef

Inherited from Any

Ungrouped