// Copyright 2016-2023, Pulumi Corporation.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by gen-pux-applyn; DO NOT EDIT.

//nolint:lll
package pulumix

import (
	"context"

	"github.com/pulumi/pulumi/sdk/v3/go/internal"
)

// ApplyContextErr applies a function to an input,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func ApplyContextErr[A1, B any](
	ctx context.Context,
	i1 Input[A1],
	fn func(A1) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)

		if applier.ok {
			b, err := fn(a1)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// ApplyContext applies a function to an input,
// returning an Output holding the result of the function.
//
// This is a variant of ApplyContextErr
// that does not allow the function to return an error.
func ApplyContext[A1, B any](
	ctx context.Context,
	i1 Input[A1],
	fn func(A1) B,
) Output[B] {
	return ApplyContextErr(
		ctx,
		i1,
		func(a1 A1) (B, error) {
			return fn(a1), nil
		},
	)
}

// ApplyErr applies a function to an input,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of ApplyContextErr
// that uses the background context.
func ApplyErr[A1, B any](
	i1 Input[A1],
	fn func(A1) (B, error),
) Output[B] {
	ctx := context.Background()
	return ApplyContextErr(ctx, i1, fn)
}

// Apply applies a function to an input,
// returning an Output holding the result of the function.
//
// This is a variant of ApplyContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply[A1, B any](
	i1 Input[A1],
	fn func(A1) B,
) Output[B] {
	ctx := context.Background()
	return ApplyContext(ctx, i1, fn)
}

// Apply2ContextErr applies a function to 2 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply2ContextErr[A1, A2, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)

		if applier.ok {
			b, err := fn(a1, a2)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply2Context applies a function to 2 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply2ContextErr
// that does not allow the function to return an error.
func Apply2Context[A1, A2, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) B,
) Output[B] {
	return Apply2ContextErr(
		ctx,
		i1, i2,
		func(a1 A1, a2 A2) (B, error) {
			return fn(a1, a2), nil
		},
	)
}

// Apply2Err applies a function to 2 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply2ContextErr
// that uses the background context.
func Apply2Err[A1, A2, B any](
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply2ContextErr(ctx, i1, i2, fn)
}

// Apply2 applies a function to 2 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply2ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply2[A1, A2, B any](
	i1 Input[A1], i2 Input[A2],
	fn func(A1, A2) B,
) Output[B] {
	ctx := context.Background()
	return Apply2Context(ctx, i1, i2, fn)
}

// Apply3ContextErr applies a function to 3 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply3ContextErr[A1, A2, A3, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)
	o3 := i3.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)
	allDeps = append(allDeps, internal.OutputDependencies(o3)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2
		var a3 A3

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)
		applyNStep[A3](ctx, &applier, o3, &a3)

		if applier.ok {
			b, err := fn(a1, a2, a3)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply3Context applies a function to 3 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply3ContextErr
// that does not allow the function to return an error.
func Apply3Context[A1, A2, A3, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) B,
) Output[B] {
	return Apply3ContextErr(
		ctx,
		i1, i2, i3,
		func(a1 A1, a2 A2, a3 A3) (B, error) {
			return fn(a1, a2, a3), nil
		},
	)
}

// Apply3Err applies a function to 3 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply3ContextErr
// that uses the background context.
func Apply3Err[A1, A2, A3, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply3ContextErr(ctx, i1, i2, i3, fn)
}

// Apply3 applies a function to 3 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply3ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply3[A1, A2, A3, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3],
	fn func(A1, A2, A3) B,
) Output[B] {
	ctx := context.Background()
	return Apply3Context(ctx, i1, i2, i3, fn)
}

// Apply4ContextErr applies a function to 4 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply4ContextErr[A1, A2, A3, A4, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)
	o3 := i3.ToOutput(ctx)
	o4 := i4.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)
	allDeps = append(allDeps, internal.OutputDependencies(o3)...)
	allDeps = append(allDeps, internal.OutputDependencies(o4)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2
		var a3 A3
		var a4 A4

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)
		applyNStep[A3](ctx, &applier, o3, &a3)
		applyNStep[A4](ctx, &applier, o4, &a4)

		if applier.ok {
			b, err := fn(a1, a2, a3, a4)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply4Context applies a function to 4 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply4ContextErr
// that does not allow the function to return an error.
func Apply4Context[A1, A2, A3, A4, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) B,
) Output[B] {
	return Apply4ContextErr(
		ctx,
		i1, i2, i3, i4,
		func(a1 A1, a2 A2, a3 A3, a4 A4) (B, error) {
			return fn(a1, a2, a3, a4), nil
		},
	)
}

// Apply4Err applies a function to 4 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply4ContextErr
// that uses the background context.
func Apply4Err[A1, A2, A3, A4, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply4ContextErr(ctx, i1, i2, i3, i4, fn)
}

// Apply4 applies a function to 4 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply4ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply4[A1, A2, A3, A4, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4],
	fn func(A1, A2, A3, A4) B,
) Output[B] {
	ctx := context.Background()
	return Apply4Context(ctx, i1, i2, i3, i4, fn)
}

// Apply5ContextErr applies a function to 5 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply5ContextErr[A1, A2, A3, A4, A5, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)
	o3 := i3.ToOutput(ctx)
	o4 := i4.ToOutput(ctx)
	o5 := i5.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)
	allDeps = append(allDeps, internal.OutputDependencies(o3)...)
	allDeps = append(allDeps, internal.OutputDependencies(o4)...)
	allDeps = append(allDeps, internal.OutputDependencies(o5)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2
		var a3 A3
		var a4 A4
		var a5 A5

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)
		applyNStep[A3](ctx, &applier, o3, &a3)
		applyNStep[A4](ctx, &applier, o4, &a4)
		applyNStep[A5](ctx, &applier, o5, &a5)

		if applier.ok {
			b, err := fn(a1, a2, a3, a4, a5)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply5Context applies a function to 5 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply5ContextErr
// that does not allow the function to return an error.
func Apply5Context[A1, A2, A3, A4, A5, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) B,
) Output[B] {
	return Apply5ContextErr(
		ctx,
		i1, i2, i3, i4, i5,
		func(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (B, error) {
			return fn(a1, a2, a3, a4, a5), nil
		},
	)
}

// Apply5Err applies a function to 5 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply5ContextErr
// that uses the background context.
func Apply5Err[A1, A2, A3, A4, A5, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply5ContextErr(ctx, i1, i2, i3, i4, i5, fn)
}

// Apply5 applies a function to 5 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply5ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply5[A1, A2, A3, A4, A5, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5],
	fn func(A1, A2, A3, A4, A5) B,
) Output[B] {
	ctx := context.Background()
	return Apply5Context(ctx, i1, i2, i3, i4, i5, fn)
}

// Apply6ContextErr applies a function to 6 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply6ContextErr[A1, A2, A3, A4, A5, A6, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)
	o3 := i3.ToOutput(ctx)
	o4 := i4.ToOutput(ctx)
	o5 := i5.ToOutput(ctx)
	o6 := i6.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)
	allDeps = append(allDeps, internal.OutputDependencies(o3)...)
	allDeps = append(allDeps, internal.OutputDependencies(o4)...)
	allDeps = append(allDeps, internal.OutputDependencies(o5)...)
	allDeps = append(allDeps, internal.OutputDependencies(o6)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2
		var a3 A3
		var a4 A4
		var a5 A5
		var a6 A6

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)
		applyNStep[A3](ctx, &applier, o3, &a3)
		applyNStep[A4](ctx, &applier, o4, &a4)
		applyNStep[A5](ctx, &applier, o5, &a5)
		applyNStep[A6](ctx, &applier, o6, &a6)

		if applier.ok {
			b, err := fn(a1, a2, a3, a4, a5, a6)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply6Context applies a function to 6 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply6ContextErr
// that does not allow the function to return an error.
func Apply6Context[A1, A2, A3, A4, A5, A6, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) B,
) Output[B] {
	return Apply6ContextErr(
		ctx,
		i1, i2, i3, i4, i5, i6,
		func(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (B, error) {
			return fn(a1, a2, a3, a4, a5, a6), nil
		},
	)
}

// Apply6Err applies a function to 6 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply6ContextErr
// that uses the background context.
func Apply6Err[A1, A2, A3, A4, A5, A6, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply6ContextErr(ctx, i1, i2, i3, i4, i5, i6, fn)
}

// Apply6 applies a function to 6 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply6ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply6[A1, A2, A3, A4, A5, A6, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6],
	fn func(A1, A2, A3, A4, A5, A6) B,
) Output[B] {
	ctx := context.Background()
	return Apply6Context(ctx, i1, i2, i3, i4, i5, i6, fn)
}

// Apply7ContextErr applies a function to 7 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply7ContextErr[A1, A2, A3, A4, A5, A6, A7, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)
	o3 := i3.ToOutput(ctx)
	o4 := i4.ToOutput(ctx)
	o5 := i5.ToOutput(ctx)
	o6 := i6.ToOutput(ctx)
	o7 := i7.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)
	allDeps = append(allDeps, internal.OutputDependencies(o3)...)
	allDeps = append(allDeps, internal.OutputDependencies(o4)...)
	allDeps = append(allDeps, internal.OutputDependencies(o5)...)
	allDeps = append(allDeps, internal.OutputDependencies(o6)...)
	allDeps = append(allDeps, internal.OutputDependencies(o7)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2
		var a3 A3
		var a4 A4
		var a5 A5
		var a6 A6
		var a7 A7

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)
		applyNStep[A3](ctx, &applier, o3, &a3)
		applyNStep[A4](ctx, &applier, o4, &a4)
		applyNStep[A5](ctx, &applier, o5, &a5)
		applyNStep[A6](ctx, &applier, o6, &a6)
		applyNStep[A7](ctx, &applier, o7, &a7)

		if applier.ok {
			b, err := fn(a1, a2, a3, a4, a5, a6, a7)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply7Context applies a function to 7 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply7ContextErr
// that does not allow the function to return an error.
func Apply7Context[A1, A2, A3, A4, A5, A6, A7, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) B,
) Output[B] {
	return Apply7ContextErr(
		ctx,
		i1, i2, i3, i4, i5, i6, i7,
		func(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (B, error) {
			return fn(a1, a2, a3, a4, a5, a6, a7), nil
		},
	)
}

// Apply7Err applies a function to 7 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply7ContextErr
// that uses the background context.
func Apply7Err[A1, A2, A3, A4, A5, A6, A7, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply7ContextErr(ctx, i1, i2, i3, i4, i5, i6, i7, fn)
}

// Apply7 applies a function to 7 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply7ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply7[A1, A2, A3, A4, A5, A6, A7, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7],
	fn func(A1, A2, A3, A4, A5, A6, A7) B,
) Output[B] {
	ctx := context.Background()
	return Apply7Context(ctx, i1, i2, i3, i4, i5, i6, i7, fn)
}

// Apply8ContextErr applies a function to 8 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
func Apply8ContextErr[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) (B, error),
) Output[B] {
	o1 := i1.ToOutput(ctx)
	o2 := i2.ToOutput(ctx)
	o3 := i3.ToOutput(ctx)
	o4 := i4.ToOutput(ctx)
	o5 := i5.ToOutput(ctx)
	o6 := i6.ToOutput(ctx)
	o7 := i7.ToOutput(ctx)
	o8 := i8.ToOutput(ctx)

	var allDeps []internal.Resource
	allDeps = append(allDeps, internal.OutputDependencies(o1)...)
	allDeps = append(allDeps, internal.OutputDependencies(o2)...)
	allDeps = append(allDeps, internal.OutputDependencies(o3)...)
	allDeps = append(allDeps, internal.OutputDependencies(o4)...)
	allDeps = append(allDeps, internal.OutputDependencies(o5)...)
	allDeps = append(allDeps, internal.OutputDependencies(o6)...)
	allDeps = append(allDeps, internal.OutputDependencies(o7)...)
	allDeps = append(allDeps, internal.OutputDependencies(o8)...)

	var wg internal.WorkGroup
	state := internal.NewOutputState(&wg, typeOf[B](), allDeps...)
	go func() {
		var a1 A1
		var a2 A2
		var a3 A3
		var a4 A4
		var a5 A5
		var a6 A6
		var a7 A7
		var a8 A8

		applier := newApplyNState[B](state)
		applyNStep[A1](ctx, &applier, o1, &a1)
		applyNStep[A2](ctx, &applier, o2, &a2)
		applyNStep[A3](ctx, &applier, o3, &a3)
		applyNStep[A4](ctx, &applier, o4, &a4)
		applyNStep[A5](ctx, &applier, o5, &a5)
		applyNStep[A6](ctx, &applier, o6, &a6)
		applyNStep[A7](ctx, &applier, o7, &a7)
		applyNStep[A8](ctx, &applier, o8, &a8)

		if applier.ok {
			b, err := fn(a1, a2, a3, a4, a5, a6, a7, a8)
			applier.finish(b, err)
		}
	}()

	return Output[B]{OutputState: state}
}

// Apply8Context applies a function to 8 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply8ContextErr
// that does not allow the function to return an error.
func Apply8Context[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	ctx context.Context,
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) B,
) Output[B] {
	return Apply8ContextErr(
		ctx,
		i1, i2, i3, i4, i5, i6, i7, i8,
		func(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (B, error) {
			return fn(a1, a2, a3, a4, a5, a6, a7, a8), nil
		},
	)
}

// Apply8Err applies a function to 8 inputs,
// returning an Output holding the result of the function.
//
// If the function returns an error, the Output will be in an error state.
//
// This is a variant of Apply8ContextErr
// that uses the background context.
func Apply8Err[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) (B, error),
) Output[B] {
	ctx := context.Background()
	return Apply8ContextErr(ctx, i1, i2, i3, i4, i5, i6, i7, i8, fn)
}

// Apply8 applies a function to 8 inputs,
// returning an Output holding the result of the function.
//
// This is a variant of Apply8ContextErr
// that does not allow the function to return an error,
// and uses the background context.
func Apply8[A1, A2, A3, A4, A5, A6, A7, A8, B any](
	i1 Input[A1], i2 Input[A2], i3 Input[A3], i4 Input[A4], i5 Input[A5], i6 Input[A6], i7 Input[A7], i8 Input[A8],
	fn func(A1, A2, A3, A4, A5, A6, A7, A8) B,
) Output[B] {
	ctx := context.Background()
	return Apply8Context(ctx, i1, i2, i3, i4, i5, i6, i7, i8, fn)
}