SequenceBuilder

class SequenceBuilder<T> : Operators

Sequence builder, you will interact with it only by using the seq operator. To register a parsing expression as an element of the sequence, use the unary plus operator. You also must use the value block, which yields the result of the sequence.

Samples

import io.kpeg.pe.Symbol.Rule
fun main() { 
   //sampleStart 
   // John 42     - OK
// John 402    - OK
// John -4     - FAIL
// John 0      - OK
// John 034034 - OK
// Jon 42      - FAIL

data class Person(val name: String, val age: Int)

seq<Person> {
    val name = +literal("John")                  // EvalPE<String>
    val age =
        +DIGIT.oneOrMore()                       // EvalPE<List<Char>>
            .joinToString().mapPe { it.toInt() } // EvalPE<Int>

    value { Person(name.get, age.get) }
}                                                // EvalPE<Person> 
   //sampleEnd
}

Types

ValueBuilder

object ValueBuilder

Value builder, you will interact with it only by using the value function.

Functions

and

fun and(pe: EvalPE<*>): EvalPE<Unit>

"And" predicate on the pe parsing expression.

char

fun char(c: Char): EvalPE<Char>

Parsing expression that represents the character c.

fun char(b: CharacterBuilderBlock): EvalPE<Char>

Parsing expression that represents any character that satisfies the b lambda.

fun char(r: CharRange): EvalPE<Char>

Parsing expression that represents any character in the char range r.

fun char(firstC: Char, secondC: Char, vararg otherCs: Char): EvalPE<Char>

Parsing expression that represents any character from the firstC, secondC, or otherCs characters.

choice

fun <T> choice(firstPe: EvalPE<T>, secondPe: EvalPE<T>, vararg otherPes: EvalPE<T>): EvalPE<T>

Prioritized choice of parsing expressions.

joinToString

fun <T> EvalPE<List<T>>.joinToString(separator: CharSequence = "", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): EvalPE<String>

This function works just like the joinToString from the standard library, but for the parsing expressions.

list

fun <T> EvalPE<T>.list(separator: EvalPE<*>? = null, prefix: EvalPE<*>? = null, postfix: EvalPE<*>? = null, min: UInt = 0u, max: UInt = UInt.MAX_VALUE): EvalPE<List<T>>

Parsing expression that represents a list of elements with the optionally defined separator, prefix, and postfix.

literal

fun literal(l: String): EvalPE<String>

Parsing expression that represents the literal l.

fun literal(len: Int, b: LiteralBuilderBlock): EvalPE<String>

Parsing expression that represents any literal of length len that satisfies the b lambda.

mapPe