xarpeg/io.github.mirrgieriana.xarpeg.parsers/ListParser

ListParser

class ListParser<out T : Any>(val parser: Parser<T>, val min: Int, val max: Int) : Parser<List<T>>

Constructors

ListParser

constructor(parser: Parser<T>, min: Int, max: Int)

Properties

capture

val <T : Any> Parser<T>.capture: Parser<Tuple1<T>>

hidden

val <T : Any> Parser<T>.hidden: NamedParser<T>

ignore

val Parser<*>.ignore: Parser<Tuple0>

Tuple0 にマッピングすることにより、このパーサーの解析結果が無視されるようにします。

lookAhead

val <T : Any> Parser<T>.lookAhead: Parser<T>

max

val max: Int

min

val min: Int

name

open val name: String?

nameOrString

val Parser<*>.nameOrString: String

negativeLookAhead

val Parser<*>.negativeLookAhead: Parser<Tuple0>

not

val Parser<*>.not: Parser<Tuple0>

oneOrMore

val <T : Any> Parser<T>.oneOrMore: ListParser<T>

optional

val <T : Any> Parser<T>.optional: OptionalParser<T>

parser

val parser: Parser<T>

result

val <T : Any> Parser<T>.result: Parser<ParseResult<T>>

zeroOrMore

val <T : Any> Parser<T>.zeroOrMore: ListParser<T>

Functions

list

fun <T : Any> Parser<T>.list(min: Int = 0, max: Int = Int.MAX_VALUE): ListParser<T>

map

infix fun Parser.map(function: (I) -> O): Parser<O>

mapEx

infix fun Parser.mapEx(function: (ParseContext, ParseResult) -> O): Parser<O>

named

infix fun <T : Any> Parser<T>.named(name: String): NamedParser<T>

parseAll

fun <T : Any> Parser<T>.parseAll(src: String): Result<T>

fun <T : Any, C : ParseContext> Parser<T>.parseAll(src: String, contextFactory: (String) -> C): Result<T>

parseOrNull

open override fun parseOrNull(context: ParseContext, start: Int): ParseResult<List<T>>?

plus

operator fun <T : Any> Parser<T>.plus(other: Parser<T>): OrParser<T>

times

@JvmName(name = "timesPP")

operator fun <A : Any, B : Any> Parser<A>.times(other: Parser): Parser<Tuple2<A, B>>

@JvmName(name = "timesP0")

operator fun <A : Any> Parser<A>.times(other: Parser<Tuple0>): Parser<A>

@JvmName(name = "timesP10")

operator fun <A : Any, B, C, D, E, F, G, H, I, J, K> Parser<A>.times(other: Parser<Tuple10<B, C, D, E, F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "timesP11")

operator fun <A : Any, B, C, D, E, F, G, H, I, J, K, L> Parser<A>.times(other: Parser<Tuple11<B, C, D, E, F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "timesP12")

operator fun <A : Any, B, C, D, E, F, G, H, I, J, K, L, M> Parser<A>.times(other: Parser<Tuple12<B, C, D, E, F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "timesP13")

operator fun <A : Any, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<A>.times(other: Parser<Tuple13<B, C, D, E, F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "timesP14")

operator fun <A : Any, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<A>.times(other: Parser<Tuple14<B, C, D, E, F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "timesP15")

operator fun <A : Any, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<A>.times(other: Parser<Tuple15<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "timesP1")

operator fun <A : Any, B> Parser<A>.times(other: Parser<Tuple1>): Parser<Tuple2<A, B>>

@JvmName(name = "timesP2")

operator fun <A : Any, B, C> Parser<A>.times(other: Parser<Tuple2<B, C>>): Parser<Tuple3<A, B, C>>

@JvmName(name = "timesP3")

operator fun <A : Any, B, C, D> Parser<A>.times(other: Parser<Tuple3<B, C, D>>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "timesP4")

operator fun <A : Any, B, C, D, E> Parser<A>.times(other: Parser<Tuple4<B, C, D, E>>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "timesP5")

operator fun <A : Any, B, C, D, E, F> Parser<A>.times(other: Parser<Tuple5<B, C, D, E, F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "timesP6")

operator fun <A : Any, B, C, D, E, F, G> Parser<A>.times(other: Parser<Tuple6<B, C, D, E, F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "timesP7")

operator fun <A : Any, B, C, D, E, F, G, H> Parser<A>.times(other: Parser<Tuple7<B, C, D, E, F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "timesP8")

operator fun <A : Any, B, C, D, E, F, G, H, I> Parser<A>.times(other: Parser<Tuple8<B, C, D, E, F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "timesP9")

operator fun <A : Any, B, C, D, E, F, G, H, I, J> Parser<A>.times(other: Parser<Tuple9<B, C, D, E, F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times0P")

operator fun <A : Any> Parser<Tuple0>.times(other: Parser<A>): Parser<A>

@JvmName(name = "times00")

operator fun Parser<Tuple0>.times(other: Parser<Tuple0>): Parser<Tuple0>

@JvmName(name = "times010")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple0>.times(other: Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times011")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple0>.times(other: Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times012")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple0>.times(other: Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times013")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple0>.times(other: Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times014")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple0>.times(other: Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times015")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple0>.times(other: Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times016")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple0>.times(other: Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times01")

operator fun <A> Parser<Tuple0>.times(other: Parser<Tuple1<A>>): Parser<Tuple1<A>>

@JvmName(name = "times02")

operator fun <A, B> Parser<Tuple0>.times(other: Parser<Tuple2<A, B>>): Parser<Tuple2<A, B>>

@JvmName(name = "times03")

operator fun <A, B, C> Parser<Tuple0>.times(other: Parser<Tuple3<A, B, C>>): Parser<Tuple3<A, B, C>>

@JvmName(name = "times04")

operator fun <A, B, C, D> Parser<Tuple0>.times(other: Parser<Tuple4<A, B, C, D>>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "times05")

operator fun <A, B, C, D, E> Parser<Tuple0>.times(other: Parser<Tuple5<A, B, C, D, E>>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times06")

operator fun <A, B, C, D, E, F> Parser<Tuple0>.times(other: Parser<Tuple6<A, B, C, D, E, F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times07")

operator fun <A, B, C, D, E, F, G> Parser<Tuple0>.times(other: Parser<Tuple7<A, B, C, D, E, F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times08")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple0>.times(other: Parser<Tuple8<A, B, C, D, E, F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times09")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple0>.times(other: Parser<Tuple9<A, B, C, D, E, F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times10P")

operator fun <A, B, C, D, E, F, G, H, I, J, K : Any> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<K>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times100")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple0>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times10_1")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple1<K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times10_2")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple2<K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times10_3")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple3<K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times10_4")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple4<K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times10_5")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple5<K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times10_6")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>.times(other: Parser<Tuple6<K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times11P")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L : Any> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<L>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times110")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<Tuple0>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times11_1")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<Tuple1<L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times11_2")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<Tuple2<L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times11_3")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<Tuple3<L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times11_4")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<Tuple4<L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times11_5")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>.times(other: Parser<Tuple5<L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times12P")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M : Any> Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>.times(other: Parser<M>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times120")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>.times(other: Parser<Tuple0>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times12_1")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>.times(other: Parser<Tuple1<M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times12_2")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>.times(other: Parser<Tuple2<M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times12_3")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>.times(other: Parser<Tuple3<M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times12_4")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>.times(other: Parser<Tuple4<M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times13P")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N : Any> Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>.times(other: Parser<N>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times130")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>.times(other: Parser<Tuple0>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times13_1")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>.times(other: Parser<Tuple1<N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times13_2")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>.times(other: Parser<Tuple2<N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times13_3")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>.times(other: Parser<Tuple3<N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times14P")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O : Any> Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>.times(other: Parser<O>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times140")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>.times(other: Parser<Tuple0>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times14_1")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>.times(other: Parser<Tuple1<O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times14_2")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>.times(other: Parser<Tuple2<O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times15P")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P : Any> Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>.times(other: Parser): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times150")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>.times(other: Parser<Tuple0>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times15_1")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>.times(other: Parser<Tuple1>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times160")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>.times(other: Parser<Tuple0>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times1P")

operator fun <A, B : Any> Parser<Tuple1<A>>.times(other: Parser): Parser<Tuple2<A, B>>

@JvmName(name = "times10")

operator fun <A> Parser<Tuple1<A>>.times(other: Parser<Tuple0>): Parser<Tuple1<A>>

@JvmName(name = "times1_10")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple1<A>>.times(other: Parser<Tuple10<B, C, D, E, F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times1_11")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple1<A>>.times(other: Parser<Tuple11<B, C, D, E, F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times1_12")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple1<A>>.times(other: Parser<Tuple12<B, C, D, E, F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times1_13")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple1<A>>.times(other: Parser<Tuple13<B, C, D, E, F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times1_14")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple1<A>>.times(other: Parser<Tuple14<B, C, D, E, F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times1_15")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple1<A>>.times(other: Parser<Tuple15<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times1_1")

operator fun <A, B> Parser<Tuple1<A>>.times(other: Parser<Tuple1>): Parser<Tuple2<A, B>>

@JvmName(name = "times1_2")

operator fun <A, B, C> Parser<Tuple1<A>>.times(other: Parser<Tuple2<B, C>>): Parser<Tuple3<A, B, C>>

@JvmName(name = "times1_3")

operator fun <A, B, C, D> Parser<Tuple1<A>>.times(other: Parser<Tuple3<B, C, D>>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "times1_4")

operator fun <A, B, C, D, E> Parser<Tuple1<A>>.times(other: Parser<Tuple4<B, C, D, E>>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times1_5")

operator fun <A, B, C, D, E, F> Parser<Tuple1<A>>.times(other: Parser<Tuple5<B, C, D, E, F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times1_6")

operator fun <A, B, C, D, E, F, G> Parser<Tuple1<A>>.times(other: Parser<Tuple6<B, C, D, E, F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times1_7")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple1<A>>.times(other: Parser<Tuple7<B, C, D, E, F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times1_8")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple1<A>>.times(other: Parser<Tuple8<B, C, D, E, F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times1_9")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple1<A>>.times(other: Parser<Tuple9<B, C, D, E, F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times2P")

operator fun <A, B, C : Any> Parser<Tuple2<A, B>>.times(other: Parser<C>): Parser<Tuple3<A, B, C>>

@JvmName(name = "times20")

operator fun <A, B> Parser<Tuple2<A, B>>.times(other: Parser<Tuple0>): Parser<Tuple2<A, B>>

@JvmName(name = "times2_10")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple2<A, B>>.times(other: Parser<Tuple10<C, D, E, F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times2_11")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple2<A, B>>.times(other: Parser<Tuple11<C, D, E, F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times2_12")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple2<A, B>>.times(other: Parser<Tuple12<C, D, E, F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times2_13")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple2<A, B>>.times(other: Parser<Tuple13<C, D, E, F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times2_14")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple2<A, B>>.times(other: Parser<Tuple14<C, D, E, F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times2_1")

operator fun <A, B, C> Parser<Tuple2<A, B>>.times(other: Parser<Tuple1<C>>): Parser<Tuple3<A, B, C>>

@JvmName(name = "times2_2")

operator fun <A, B, C, D> Parser<Tuple2<A, B>>.times(other: Parser<Tuple2<C, D>>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "times2_3")

operator fun <A, B, C, D, E> Parser<Tuple2<A, B>>.times(other: Parser<Tuple3<C, D, E>>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times2_4")

operator fun <A, B, C, D, E, F> Parser<Tuple2<A, B>>.times(other: Parser<Tuple4<C, D, E, F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times2_5")

operator fun <A, B, C, D, E, F, G> Parser<Tuple2<A, B>>.times(other: Parser<Tuple5<C, D, E, F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times2_6")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple2<A, B>>.times(other: Parser<Tuple6<C, D, E, F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times2_7")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple2<A, B>>.times(other: Parser<Tuple7<C, D, E, F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times2_8")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple2<A, B>>.times(other: Parser<Tuple8<C, D, E, F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times2_9")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple2<A, B>>.times(other: Parser<Tuple9<C, D, E, F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times3P")

operator fun <A, B, C, D : Any> Parser<Tuple3<A, B, C>>.times(other: Parser<D>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "times30")

operator fun <A, B, C> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple0>): Parser<Tuple3<A, B, C>>

@JvmName(name = "times3_10")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple10<D, E, F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times3_11")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple11<D, E, F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times3_12")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple12<D, E, F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times3_13")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple13<D, E, F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times3_1")

operator fun <A, B, C, D> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple1<D>>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "times3_2")

operator fun <A, B, C, D, E> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple2<D, E>>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times3_3")

operator fun <A, B, C, D, E, F> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple3<D, E, F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times3_4")

operator fun <A, B, C, D, E, F, G> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple4<D, E, F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times3_5")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple5<D, E, F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times3_6")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple6<D, E, F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times3_7")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple7<D, E, F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times3_8")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple8<D, E, F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times3_9")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple3<A, B, C>>.times(other: Parser<Tuple9<D, E, F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times4P")

operator fun <A, B, C, D, E : Any> Parser<Tuple4<A, B, C, D>>.times(other: Parser<E>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times40")

operator fun <A, B, C, D> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple0>): Parser<Tuple4<A, B, C, D>>

@JvmName(name = "times4_10")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple10<E, F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times4_11")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple11<E, F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times4_12")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple12<E, F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times4_1")

operator fun <A, B, C, D, E> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple1<E>>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times4_2")

operator fun <A, B, C, D, E, F> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple2<E, F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times4_3")

operator fun <A, B, C, D, E, F, G> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple3<E, F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times4_4")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple4<E, F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times4_5")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple5<E, F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times4_6")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple6<E, F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times4_7")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple7<E, F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times4_8")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple8<E, F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times4_9")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple4<A, B, C, D>>.times(other: Parser<Tuple9<E, F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times5P")

operator fun <A, B, C, D, E, F : Any> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<F>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times50")

operator fun <A, B, C, D, E> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple0>): Parser<Tuple5<A, B, C, D, E>>

@JvmName(name = "times5_10")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple10<F, G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times5_11")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple11<F, G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times5_1")

operator fun <A, B, C, D, E, F> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple1<F>>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times5_2")

operator fun <A, B, C, D, E, F, G> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple2<F, G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times5_3")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple3<F, G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times5_4")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple4<F, G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times5_5")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple5<F, G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times5_6")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple6<F, G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times5_7")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple7<F, G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times5_8")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple8<F, G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times5_9")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple5<A, B, C, D, E>>.times(other: Parser<Tuple9<F, G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times6P")

operator fun <A, B, C, D, E, F, G : Any> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<G>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times60")

operator fun <A, B, C, D, E, F> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple0>): Parser<Tuple6<A, B, C, D, E, F>>

@JvmName(name = "times6_10")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple10<G, H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times6_1")

operator fun <A, B, C, D, E, F, G> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple1<G>>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times6_2")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple2<G, H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times6_3")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple3<G, H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times6_4")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple4<G, H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times6_5")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple5<G, H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times6_6")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple6<G, H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times6_7")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple7<G, H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times6_8")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple8<G, H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times6_9")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple6<A, B, C, D, E, F>>.times(other: Parser<Tuple9<G, H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times7P")

operator fun <A, B, C, D, E, F, G, H : Any> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<H>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times70")

operator fun <A, B, C, D, E, F, G> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple0>): Parser<Tuple7<A, B, C, D, E, F, G>>

@JvmName(name = "times7_1")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple1<H>>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times7_2")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple2<H, I>>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times7_3")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple3<H, I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times7_4")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple4<H, I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times7_5")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple5<H, I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times7_6")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple6<H, I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times7_7")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple7<H, I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times7_8")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple8<H, I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times7_9")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple7<A, B, C, D, E, F, G>>.times(other: Parser<Tuple9<H, I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times8P")

operator fun <A, B, C, D, E, F, G, H, I : Any> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times80")

operator fun <A, B, C, D, E, F, G, H> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple0>): Parser<Tuple8<A, B, C, D, E, F, G, H>>

@JvmName(name = "times8_1")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple1>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times8_2")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple2<I, J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times8_3")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple3<I, J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times8_4")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple4<I, J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times8_5")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple5<I, J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times8_6")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple6<I, J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times8_7")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple7<I, J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times8_8")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple8<A, B, C, D, E, F, G, H>>.times(other: Parser<Tuple8<I, J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

@JvmName(name = "times9P")

operator fun <A, B, C, D, E, F, G, H, I, J : Any> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<J>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times90")

operator fun <A, B, C, D, E, F, G, H, I> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple0>): Parser<Tuple9<A, B, C, D, E, F, G, H, I>>

@JvmName(name = "times9_1")

operator fun <A, B, C, D, E, F, G, H, I, J> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple1<J>>): Parser<Tuple10<A, B, C, D, E, F, G, H, I, J>>

@JvmName(name = "times9_2")

operator fun <A, B, C, D, E, F, G, H, I, J, K> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple2<J, K>>): Parser<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

@JvmName(name = "times9_3")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple3<J, K, L>>): Parser<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

@JvmName(name = "times9_4")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple4<J, K, L, M>>): Parser<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

@JvmName(name = "times9_5")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple5<J, K, L, M, N>>): Parser<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

@JvmName(name = "times9_6")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple6<J, K, L, M, N, O>>): Parser<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

@JvmName(name = "times9_7")

operator fun <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Parser<Tuple9<A, B, C, D, E, F, G, H, I>>.times(other: Parser<Tuple7<J, K, L, M, N, O, P>>): Parser<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

unaryMinus

operator fun Parser<*>.unaryMinus(): Parser<Tuple0>

Tuple0 にマッピングすることにより、このパーサーの解析結果が無視されるようにします。

unaryPlus

operator fun <T : Any> Parser<T>.unaryPlus(): Parser<Tuple1<T>>