gigaparsec/bind.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()
		if r.Failed() {
			return Fail[In, Out](anyConsumed, r.Message()), nil
		}
		_, val, next := r.Succeeded()

		r2, err := f(val)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r2.Consumed()
		if r2.Failed() {
			return Fail[In, Out](anyConsumed, r2.Message()), nil
		}
		_, val2, next := r2.Succeeded()

		return Succeed(anyConsumed, val2, next, MessageOK(s.Pos())), 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()
		if r.Failed() {
			return Fail[In, Out](anyConsumed, r.Message()), nil
		}
		_, val, next := r.Succeeded()

		r2, err := f(val)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r2.Consumed()
		if r2.Failed() {
			return Fail[In, Out](anyConsumed, r2.Message()), nil
		}
		_, val2, next := r2.Succeeded()

		r3, err := f2(val2)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r3.Consumed()
		if r3.Failed() {
			return Fail[In, Out](anyConsumed, r3.Message()), nil
		}
		_, val3, next := r3.Succeeded()

		return Succeed(anyConsumed, val3, next, MessageOK(s.Pos())), 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()
		if r.Failed() {
			return Fail[In, Out](anyConsumed, r.Message()), nil
		}
		_, val, next := r.Succeeded()

		r2, err := f(val)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r2.Consumed()
		if r2.Failed() {
			return Fail[In, Out](anyConsumed, r2.Message()), nil
		}
		_, val2, next := r2.Succeeded()

		r3, err := f2(val2)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r3.Consumed()
		if r3.Failed() {
			return Fail[In, Out](anyConsumed, r3.Message()), nil
		}
		_, val3, next := r3.Succeeded()

		r4, err := f3(val3)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r4.Consumed()
		if r4.Failed() {
			return Fail[In, Out](anyConsumed, r4.Message()), nil
		}
		_, val4, next := r4.Succeeded()

		return Succeed(anyConsumed, val4, next, MessageOK(s.Pos())), 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()
		if r.Failed() {
			return Fail[In, Out](anyConsumed, r.Message()), nil
		}
		_, val, next := r.Succeeded()

		r2, err := f(val)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r2.Consumed()
		if r2.Failed() {
			return Fail[In, Out](anyConsumed, r2.Message()), nil
		}
		_, val2, next := r2.Succeeded()

		r3, err := f2(val2)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r3.Consumed()
		if r3.Failed() {
			return Fail[In, Out](anyConsumed, r3.Message()), nil
		}
		_, val3, next := r3.Succeeded()

		r4, err := f3(val3)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r4.Consumed()
		if r4.Failed() {
			return Fail[In, Out](anyConsumed, r4.Message()), nil
		}
		_, val4, next := r4.Succeeded()

		r5, err := f4(val4)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r5.Consumed()
		if r5.Failed() {
			return Fail[In, Out](anyConsumed, r5.Message()), nil
		}
		_, val5, next := r5.Succeeded()

		return Succeed(anyConsumed, val5, next, MessageOK(s.Pos())), 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()
		if r.Failed() {
			return Fail[In, Out](anyConsumed, r.Message()), nil
		}
		_, val, next := r.Succeeded()

		r2, err := f(val)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r2.Consumed()
		if r2.Failed() {
			return Fail[In, Out](anyConsumed, r2.Message()), nil
		}
		_, val2, next := r2.Succeeded()

		r3, err := f2(val2)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r3.Consumed()
		if r3.Failed() {
			return Fail[In, Out](anyConsumed, r3.Message()), nil
		}
		_, val3, next := r3.Succeeded()

		r4, err := f3(val3)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r4.Consumed()
		if r4.Failed() {
			return Fail[In, Out](anyConsumed, r4.Message()), nil
		}
		_, val4, next := r4.Succeeded()

		r5, err := f4(val4)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r5.Consumed()
		if r5.Failed() {
			return Fail[In, Out](anyConsumed, r5.Message()), nil
		}
		_, val5, next := r5.Succeeded()

		r6, err := f5(val5)(next)
		if err != nil {
			return Result[In, Out]{}, err
		}
		anyConsumed = anyConsumed || r6.Consumed()
		if r6.Failed() {
			return Fail[In, Out](anyConsumed, r6.Message()), nil
		}
		_, val6, next := r6.Succeeded()

		return Succeed(anyConsumed, val6, next, MessageOK(s.Pos())), nil
	}
}