699 lines
17 KiB
Go
699 lines
17 KiB
Go
// GENERATED FILE. DO NOT EDIT.
|
||
|
||
// SPDX-License-Identifier: Unlicense
|
||
|
||
package gigaparsec
|
||
|
||
// Bind combines p with a parser created by f that depends on p’s result value.
|
||
func Bind[In, Out, T any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val2, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind2 is equivalent to 2 nested calls to Bind.
|
||
func Bind2[In, Out, T, T2 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val3, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind3 is equivalent to 3 nested calls to Bind.
|
||
func Bind3[In, Out, T, T2, T3 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val4, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind4 is equivalent to 4 nested calls to Bind.
|
||
func Bind4[In, Out, T, T2, T3, T4 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, T4],
|
||
f4 func(T4) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
r5, err := f4(val4)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r5.Consumed()
|
||
success, val5, next := r5.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r5.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val5, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind5 is equivalent to 5 nested calls to Bind.
|
||
func Bind5[In, Out, T, T2, T3, T4, T5 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, T4],
|
||
f4 func(T4) Parser[In, T5],
|
||
f5 func(T5) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
r5, err := f4(val4)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r5.Consumed()
|
||
success, val5, next := r5.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r5.Message()), nil
|
||
}
|
||
|
||
r6, err := f5(val5)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r6.Consumed()
|
||
success, val6, next := r6.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r6.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val6, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind6 is equivalent to 6 nested calls to Bind.
|
||
func Bind6[In, Out, T, T2, T3, T4, T5, T6 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, T4],
|
||
f4 func(T4) Parser[In, T5],
|
||
f5 func(T5) Parser[In, T6],
|
||
f6 func(T6) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
r5, err := f4(val4)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r5.Consumed()
|
||
success, val5, next := r5.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r5.Message()), nil
|
||
}
|
||
|
||
r6, err := f5(val5)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r6.Consumed()
|
||
success, val6, next := r6.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r6.Message()), nil
|
||
}
|
||
|
||
r7, err := f6(val6)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r7.Consumed()
|
||
success, val7, next := r7.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r7.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val7, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind7 is equivalent to 7 nested calls to Bind.
|
||
func Bind7[In, Out, T, T2, T3, T4, T5, T6, T7 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, T4],
|
||
f4 func(T4) Parser[In, T5],
|
||
f5 func(T5) Parser[In, T6],
|
||
f6 func(T6) Parser[In, T7],
|
||
f7 func(T7) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
r5, err := f4(val4)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r5.Consumed()
|
||
success, val5, next := r5.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r5.Message()), nil
|
||
}
|
||
|
||
r6, err := f5(val5)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r6.Consumed()
|
||
success, val6, next := r6.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r6.Message()), nil
|
||
}
|
||
|
||
r7, err := f6(val6)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r7.Consumed()
|
||
success, val7, next := r7.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r7.Message()), nil
|
||
}
|
||
|
||
r8, err := f7(val7)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r8.Consumed()
|
||
success, val8, next := r8.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r8.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val8, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind8 is equivalent to 8 nested calls to Bind.
|
||
func Bind8[In, Out, T, T2, T3, T4, T5, T6, T7, T8 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, T4],
|
||
f4 func(T4) Parser[In, T5],
|
||
f5 func(T5) Parser[In, T6],
|
||
f6 func(T6) Parser[In, T7],
|
||
f7 func(T7) Parser[In, T8],
|
||
f8 func(T8) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
r5, err := f4(val4)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r5.Consumed()
|
||
success, val5, next := r5.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r5.Message()), nil
|
||
}
|
||
|
||
r6, err := f5(val5)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r6.Consumed()
|
||
success, val6, next := r6.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r6.Message()), nil
|
||
}
|
||
|
||
r7, err := f6(val6)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r7.Consumed()
|
||
success, val7, next := r7.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r7.Message()), nil
|
||
}
|
||
|
||
r8, err := f7(val7)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r8.Consumed()
|
||
success, val8, next := r8.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r8.Message()), nil
|
||
}
|
||
|
||
r9, err := f8(val8)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r9.Consumed()
|
||
success, val9, next := r9.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r9.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val9, next, s.MessageOK()), nil
|
||
}
|
||
}
|
||
|
||
// Bind9 is equivalent to 9 nested calls to Bind.
|
||
func Bind9[In, Out, T, T2, T3, T4, T5, T6, T7, T8, T9 any](
|
||
p Parser[In, T],
|
||
f func(T) Parser[In, T2],
|
||
f2 func(T2) Parser[In, T3],
|
||
f3 func(T3) Parser[In, T4],
|
||
f4 func(T4) Parser[In, T5],
|
||
f5 func(T5) Parser[In, T6],
|
||
f6 func(T6) Parser[In, T7],
|
||
f7 func(T7) Parser[In, T8],
|
||
f8 func(T8) Parser[In, T9],
|
||
f9 func(T9) Parser[In, Out],
|
||
) Parser[In, Out] {
|
||
return func(s State[In]) (Result[In, Out], error) {
|
||
var anyConsumed bool
|
||
var next = s
|
||
|
||
r, err := p(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r.Consumed()
|
||
success, val, next := r.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r.Message()), nil
|
||
}
|
||
|
||
r2, err := f(val)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r2.Consumed()
|
||
success, val2, next := r2.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r2.Message()), nil
|
||
}
|
||
|
||
r3, err := f2(val2)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r3.Consumed()
|
||
success, val3, next := r3.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r3.Message()), nil
|
||
}
|
||
|
||
r4, err := f3(val3)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r4.Consumed()
|
||
success, val4, next := r4.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r4.Message()), nil
|
||
}
|
||
|
||
r5, err := f4(val4)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r5.Consumed()
|
||
success, val5, next := r5.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r5.Message()), nil
|
||
}
|
||
|
||
r6, err := f5(val5)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r6.Consumed()
|
||
success, val6, next := r6.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r6.Message()), nil
|
||
}
|
||
|
||
r7, err := f6(val6)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r7.Consumed()
|
||
success, val7, next := r7.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r7.Message()), nil
|
||
}
|
||
|
||
r8, err := f7(val7)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r8.Consumed()
|
||
success, val8, next := r8.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r8.Message()), nil
|
||
}
|
||
|
||
r9, err := f8(val8)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r9.Consumed()
|
||
success, val9, next := r9.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r9.Message()), nil
|
||
}
|
||
|
||
r10, err := f9(val9)(next)
|
||
if err != nil {
|
||
return Result[In, Out]{}, err
|
||
}
|
||
anyConsumed = anyConsumed || r10.Consumed()
|
||
success, val10, next := r10.Status()
|
||
if !success {
|
||
return Fail[In, Out](anyConsumed, r10.Message()), nil
|
||
}
|
||
|
||
return Succeed(anyConsumed, val10, next, s.MessageOK()), nil
|
||
}
|
||
}
|