generic

package
v0.2.64 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 15, 2024 License: LGPL-2.1 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func FuncError

func FuncError(err, panicErr error) error

func PairFuncError

func PairFuncError[T any](r T, err, panicErr error) (T, error)

Types

type Action0

type Action0 func()

func MakeAction0 added in v0.2.52

func MakeAction0[F ~func()](f F) Action0

func (Action0) Call

func (f Action0) Call(autoRecover bool, reportError chan error) (panicErr error)

func (Action0) CastDelegate added in v0.2.52

func (f Action0) CastDelegate() DelegateAction0

func (Action0) Exec

func (f Action0) Exec()

func (Action0) Invoke

func (f Action0) Invoke() (panicErr error)

type Action1

type Action1[A1 any] func(A1)

func MakeAction1 added in v0.2.52

func MakeAction1[A1 any, F ~func(A1)](f F) Action1[A1]

func (Action1[A1]) Call

func (f Action1[A1]) Call(autoRecover bool, reportError chan error, a1 A1) (panicErr error)

func (Action1[A1]) CastDelegate added in v0.2.52

func (f Action1[A1]) CastDelegate() DelegateAction1[A1]

func (Action1[A1]) Exec

func (f Action1[A1]) Exec(a1 A1)

func (Action1[A1]) Invoke

func (f Action1[A1]) Invoke(a1 A1) (panicErr error)

type Action10

type Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
)

func MakeAction10 added in v0.2.52

func MakeAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
)](f F) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

func (Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call

func (f Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (panicErr error)

func (Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) CastDelegate added in v0.2.52

func (f Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) CastDelegate() DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

func (Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec

func (f Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
)

func (Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke

func (f Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (panicErr error)

type Action11

type Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
)

func MakeAction11 added in v0.2.52

func MakeAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
)](f F) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

func (Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call

func (f Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (panicErr error)

func (Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) CastDelegate added in v0.2.52

func (f Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) CastDelegate() DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

func (Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec

func (f Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
)

func (Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke

func (f Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (panicErr error)

type Action12

type Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
)

func MakeAction12 added in v0.2.52

func MakeAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
)](f F) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

func (Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call

func (f Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (panicErr error)

func (Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) CastDelegate added in v0.2.52

func (f Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) CastDelegate() DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

func (Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec

func (f Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
)

func (Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke

func (f Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (panicErr error)

type Action13

type Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
)

func MakeAction13 added in v0.2.52

func MakeAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
)](f F) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

func (Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call

func (f Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (panicErr error)

func (Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) CastDelegate added in v0.2.52

func (f Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) CastDelegate() DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

func (Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec

func (f Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
)

func (Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke

func (f Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (panicErr error)

type Action14

type Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
)

func MakeAction14 added in v0.2.52

func MakeAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
)](f F) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

func (Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call

func (f Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (panicErr error)

func (Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) CastDelegate added in v0.2.52

func (f Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) CastDelegate() DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

func (Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec

func (f Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
)

func (Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke

func (f Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (panicErr error)

type Action15

type Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
)

func MakeAction15 added in v0.2.52

func MakeAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
)](f F) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

func (Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call

func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (panicErr error)

func (Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) CastDelegate added in v0.2.52

func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) CastDelegate() DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

func (Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec

func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
)

func (Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke

func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (panicErr error)

type Action16

type Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
)

func MakeAction16 added in v0.2.52

func MakeAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
)](f F) Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

func (Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call

func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (panicErr error)

func (Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) CastDelegate added in v0.2.52

func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) CastDelegate() DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

func (Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec

func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
)

func (Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke

func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (panicErr error)

type Action2

type Action2[A1, A2 any] func(A1, A2)

func MakeAction2 added in v0.2.52

func MakeAction2[A1, A2 any, F ~func(A1, A2)](f F) Action2[A1, A2]

func (Action2[A1, A2]) Call

func (f Action2[A1, A2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (panicErr error)

func (Action2[A1, A2]) CastDelegate added in v0.2.52

func (f Action2[A1, A2]) CastDelegate() DelegateAction2[A1, A2]

func (Action2[A1, A2]) Exec

func (f Action2[A1, A2]) Exec(a1 A1, a2 A2)

func (Action2[A1, A2]) Invoke

func (f Action2[A1, A2]) Invoke(a1 A1, a2 A2) (panicErr error)

type Action3

type Action3[A1, A2, A3 any] func(A1, A2, A3)

func MakeAction3 added in v0.2.52

func MakeAction3[A1, A2, A3 any, F ~func(A1, A2, A3)](f F) Action3[A1, A2, A3]

func (Action3[A1, A2, A3]) Call

func (f Action3[A1, A2, A3]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (panicErr error)

func (Action3[A1, A2, A3]) CastDelegate added in v0.2.52

func (f Action3[A1, A2, A3]) CastDelegate() DelegateAction3[A1, A2, A3]

func (Action3[A1, A2, A3]) Exec

func (f Action3[A1, A2, A3]) Exec(a1 A1, a2 A2, a3 A3)

func (Action3[A1, A2, A3]) Invoke

func (f Action3[A1, A2, A3]) Invoke(a1 A1, a2 A2, a3 A3) (panicErr error)

type Action4

type Action4[A1, A2, A3, A4 any] func(A1, A2, A3, A4)

func MakeAction4 added in v0.2.52

func MakeAction4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](f F) Action4[A1, A2, A3, A4]

func (Action4[A1, A2, A3, A4]) Call

func (f Action4[A1, A2, A3, A4]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)

func (Action4[A1, A2, A3, A4]) CastDelegate added in v0.2.52

func (f Action4[A1, A2, A3, A4]) CastDelegate() DelegateAction4[A1, A2, A3, A4]

func (Action4[A1, A2, A3, A4]) Exec

func (f Action4[A1, A2, A3, A4]) Exec(a1 A1, a2 A2, a3 A3, a4 A4)

func (Action4[A1, A2, A3, A4]) Invoke

func (f Action4[A1, A2, A3, A4]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)

type Action5

type Action5[A1, A2, A3, A4, A5 any] func(
	A1, A2, A3, A4, A5,
)

func MakeAction5 added in v0.2.52

func MakeAction5[A1, A2, A3, A4, A5 any, F ~func(
	A1, A2, A3, A4, A5,
)](f F) Action5[A1, A2, A3, A4, A5]

func (Action5[A1, A2, A3, A4, A5]) Call

func (f Action5[A1, A2, A3, A4, A5]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (panicErr error)

func (Action5[A1, A2, A3, A4, A5]) CastDelegate added in v0.2.52

func (f Action5[A1, A2, A3, A4, A5]) CastDelegate() DelegateAction5[A1, A2, A3, A4, A5]

func (Action5[A1, A2, A3, A4, A5]) Exec

func (f Action5[A1, A2, A3, A4, A5]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
)

func (Action5[A1, A2, A3, A4, A5]) Invoke

func (f Action5[A1, A2, A3, A4, A5]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (panicErr error)

type Action6

type Action6[A1, A2, A3, A4, A5, A6 any] func(
	A1, A2, A3, A4, A5, A6,
)

func MakeAction6 added in v0.2.52

func MakeAction6[A1, A2, A3, A4, A5, A6 any, F ~func(
	A1, A2, A3, A4, A5, A6,
)](f F) Action6[A1, A2, A3, A4, A5, A6]

func (Action6[A1, A2, A3, A4, A5, A6]) Call

func (f Action6[A1, A2, A3, A4, A5, A6]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (panicErr error)

func (Action6[A1, A2, A3, A4, A5, A6]) CastDelegate added in v0.2.52

func (f Action6[A1, A2, A3, A4, A5, A6]) CastDelegate() DelegateAction6[A1, A2, A3, A4, A5, A6]

func (Action6[A1, A2, A3, A4, A5, A6]) Exec

func (f Action6[A1, A2, A3, A4, A5, A6]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
)

func (Action6[A1, A2, A3, A4, A5, A6]) Invoke

func (f Action6[A1, A2, A3, A4, A5, A6]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (panicErr error)

type Action7

type Action7[A1, A2, A3, A4, A5, A6, A7 any] func(
	A1, A2, A3, A4, A5, A6, A7,
)

func MakeAction7 added in v0.2.52

func MakeAction7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
)](f F) Action7[A1, A2, A3, A4, A5, A6, A7]

func (Action7[A1, A2, A3, A4, A5, A6, A7]) Call

func (f Action7[A1, A2, A3, A4, A5, A6, A7]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (panicErr error)

func (Action7[A1, A2, A3, A4, A5, A6, A7]) CastDelegate added in v0.2.52

func (f Action7[A1, A2, A3, A4, A5, A6, A7]) CastDelegate() DelegateAction7[A1, A2, A3, A4, A5, A6, A7]

func (Action7[A1, A2, A3, A4, A5, A6, A7]) Exec

func (f Action7[A1, A2, A3, A4, A5, A6, A7]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
)

func (Action7[A1, A2, A3, A4, A5, A6, A7]) Invoke

func (f Action7[A1, A2, A3, A4, A5, A6, A7]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (panicErr error)

type Action8

type Action8[A1, A2, A3, A4, A5, A6, A7, A8 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8,
)

func MakeAction8 added in v0.2.52

func MakeAction8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
)](f F) Action8[A1, A2, A3, A4, A5, A6, A7, A8]

func (Action8[A1, A2, A3, A4, A5, A6, A7, A8]) Call

func (f Action8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (panicErr error)

func (Action8[A1, A2, A3, A4, A5, A6, A7, A8]) CastDelegate added in v0.2.52

func (f Action8[A1, A2, A3, A4, A5, A6, A7, A8]) CastDelegate() DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]

func (Action8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec

func (f Action8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
)

func (Action8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke

func (f Action8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (panicErr error)

type Action9

type Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
)

func MakeAction9 added in v0.2.52

func MakeAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
)](f F) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

func (Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call

func (f Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (panicErr error)

func (Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) CastDelegate added in v0.2.52

func (f Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) CastDelegate() DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

func (Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec

func (f Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
)

func (Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke

func (f Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (panicErr error)

type ActionVar0

type ActionVar0[VA any] func(...VA)

func MakeActionVar0 added in v0.2.52

func MakeActionVar0[VA any, F ~func(...VA)](f F) ActionVar0[VA]

func (ActionVar0[VA]) Call

func (f ActionVar0[VA]) Call(autoRecover bool, reportError chan error, va ...VA) (panicErr error)

func (ActionVar0[VA]) CastDelegate added in v0.2.52

func (f ActionVar0[VA]) CastDelegate() DelegateActionVar0[VA]

func (ActionVar0[VA]) Exec

func (f ActionVar0[VA]) Exec(va ...VA)

func (ActionVar0[VA]) Invoke

func (f ActionVar0[VA]) Invoke(va ...VA) (panicErr error)

type ActionVar1

type ActionVar1[A1, VA any] func(A1, ...VA)

func MakeActionVar1 added in v0.2.52

func MakeActionVar1[A1, VA, F ~func(A1, ...VA)](f F) ActionVar1[A1, VA]

func (ActionVar1[A1, VA]) Call

func (f ActionVar1[A1, VA]) Call(autoRecover bool, reportError chan error, a1 A1, va ...VA) (panicErr error)

func (ActionVar1[A1, VA]) CastDelegate added in v0.2.52

func (f ActionVar1[A1, VA]) CastDelegate() DelegateActionVar1[A1, VA]

func (ActionVar1[A1, VA]) Exec

func (f ActionVar1[A1, VA]) Exec(a1 A1, va ...VA)

func (ActionVar1[A1, VA]) Invoke

func (f ActionVar1[A1, VA]) Invoke(a1 A1, va ...VA) (panicErr error)

type ActionVar10

type ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
)

func MakeActionVar10 added in v0.2.52

func MakeActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
)](f F) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

func (ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call

func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (panicErr error)

func (ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) CastDelegate added in v0.2.52

func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) CastDelegate() DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

func (ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec

func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
)

func (ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke

func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (panicErr error)

type ActionVar11

type ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
)

func MakeActionVar11 added in v0.2.52

func MakeActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
)](f F) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

func (ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call

func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (panicErr error)

func (ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) CastDelegate added in v0.2.52

func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) CastDelegate() DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

func (ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec

func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
)

func (ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke

func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (panicErr error)

type ActionVar12

type ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
)

func MakeActionVar12 added in v0.2.52

func MakeActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
)](f F) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

func (ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call

func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (panicErr error)

func (ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) CastDelegate added in v0.2.52

func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) CastDelegate() DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

func (ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec

func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
)

func (ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke

func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (panicErr error)

type ActionVar13

type ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
)

func MakeActionVar13 added in v0.2.52

func MakeActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
)](f F) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

func (ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call

func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (panicErr error)

func (ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) CastDelegate added in v0.2.52

func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) CastDelegate() DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

func (ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec

func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
)

func (ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke

func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (panicErr error)

type ActionVar14

type ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
)

func MakeActionVar14 added in v0.2.52

func MakeActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
)](f F) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

func (ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call

func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (panicErr error)

func (ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) CastDelegate added in v0.2.52

func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) CastDelegate() DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

func (ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec

func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
)

func (ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke

func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (panicErr error)

type ActionVar15

type ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
)

func MakeActionVar15 added in v0.2.52

func MakeActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
)](f F) ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

func (ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call

func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (panicErr error)

func (ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) CastDelegate added in v0.2.52

func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) CastDelegate() DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

func (ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec

func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
)

func (ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke

func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (panicErr error)

type ActionVar16

type ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
)

func MakeActionVar16 added in v0.2.52

func MakeActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
)](f F) ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

func (ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call

func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (panicErr error)

func (ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) CastDelegate added in v0.2.52

func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) CastDelegate() DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

func (ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec

func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
)

func (ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke

func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (panicErr error)

type ActionVar2

type ActionVar2[A1, A2, VA any] func(A1, A2, ...VA)

func MakeActionVar2 added in v0.2.52

func MakeActionVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](f F) ActionVar2[A1, A2, VA]

func (ActionVar2[A1, A2, VA]) Call

func (f ActionVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, va ...VA) (panicErr error)

func (ActionVar2[A1, A2, VA]) CastDelegate added in v0.2.52

func (f ActionVar2[A1, A2, VA]) CastDelegate() DelegateActionVar2[A1, A2, VA]

func (ActionVar2[A1, A2, VA]) Exec

func (f ActionVar2[A1, A2, VA]) Exec(a1 A1, a2 A2, va ...VA)

func (ActionVar2[A1, A2, VA]) Invoke

func (f ActionVar2[A1, A2, VA]) Invoke(a1 A1, a2 A2, va ...VA) (panicErr error)

type ActionVar3

type ActionVar3[A1, A2, A3, VA any] func(A1, A2, A3, ...VA)

func MakeActionVar3 added in v0.2.52

func MakeActionVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](f F) ActionVar3[A1, A2, A3, VA]

func (ActionVar3[A1, A2, A3, VA]) Call

func (f ActionVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, va ...VA) (panicErr error)

func (ActionVar3[A1, A2, A3, VA]) CastDelegate added in v0.2.52

func (f ActionVar3[A1, A2, A3, VA]) CastDelegate() DelegateActionVar3[A1, A2, A3, VA]

func (ActionVar3[A1, A2, A3, VA]) Exec

func (f ActionVar3[A1, A2, A3, VA]) Exec(a1 A1, a2 A2, a3 A3, va ...VA)

func (ActionVar3[A1, A2, A3, VA]) Invoke

func (f ActionVar3[A1, A2, A3, VA]) Invoke(a1 A1, a2 A2, a3 A3, va ...VA) (panicErr error)

type ActionVar4

type ActionVar4[A1, A2, A3, A4, VA any] func(A1, A2, A3, A4, ...VA)

func MakeActionVar4 added in v0.2.52

func MakeActionVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](f F) ActionVar4[A1, A2, A3, A4, VA]

func (ActionVar4[A1, A2, A3, A4, VA]) Call

func (f ActionVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (panicErr error)

func (ActionVar4[A1, A2, A3, A4, VA]) CastDelegate added in v0.2.52

func (f ActionVar4[A1, A2, A3, A4, VA]) CastDelegate() DelegateActionVar4[A1, A2, A3, A4, VA]

func (ActionVar4[A1, A2, A3, A4, VA]) Exec

func (f ActionVar4[A1, A2, A3, A4, VA]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA)

func (ActionVar4[A1, A2, A3, A4, VA]) Invoke

func (f ActionVar4[A1, A2, A3, A4, VA]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (panicErr error)

type ActionVar5

type ActionVar5[A1, A2, A3, A4, A5, VA any] func(
	A1, A2, A3, A4, A5, ...VA,
)

func MakeActionVar5 added in v0.2.52

func MakeActionVar5[A1, A2, A3, A4, A5, VA any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
)](f F) ActionVar5[A1, A2, A3, A4, A5, VA]

func (ActionVar5[A1, A2, A3, A4, A5, VA]) Call

func (f ActionVar5[A1, A2, A3, A4, A5, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (panicErr error)

func (ActionVar5[A1, A2, A3, A4, A5, VA]) CastDelegate added in v0.2.52

func (f ActionVar5[A1, A2, A3, A4, A5, VA]) CastDelegate() DelegateActionVar5[A1, A2, A3, A4, A5, VA]

func (ActionVar5[A1, A2, A3, A4, A5, VA]) Exec

func (f ActionVar5[A1, A2, A3, A4, A5, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
)

func (ActionVar5[A1, A2, A3, A4, A5, VA]) Invoke

func (f ActionVar5[A1, A2, A3, A4, A5, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (panicErr error)

type ActionVar6

type ActionVar6[A1, A2, A3, A4, A5, A6, VA any] func(
	A1, A2, A3, A4, A5, A6, ...VA,
)

func MakeActionVar6 added in v0.2.52

func MakeActionVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
)](f F) ActionVar6[A1, A2, A3, A4, A5, A6, VA]

func (ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call

func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (panicErr error)

func (ActionVar6[A1, A2, A3, A4, A5, A6, VA]) CastDelegate added in v0.2.52

func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) CastDelegate() DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]

func (ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Exec

func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
)

func (ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke

func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (panicErr error)

type ActionVar7

type ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
)

func MakeActionVar7 added in v0.2.52

func MakeActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
)](f F) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

func (ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call

func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (panicErr error)

func (ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) CastDelegate added in v0.2.52

func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) CastDelegate() DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

func (ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec

func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
)

func (ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke

func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (panicErr error)

type ActionVar8

type ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
)

func MakeActionVar8 added in v0.2.52

func MakeActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
)](f F) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

func (ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call

func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (panicErr error)

func (ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) CastDelegate added in v0.2.52

func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) CastDelegate() DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

func (ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec

func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
)

func (ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke

func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (panicErr error)

type ActionVar9

type ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
)

func MakeActionVar9 added in v0.2.52

func MakeActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
)](f F) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

func (ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call

func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (panicErr error)

func (ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) CastDelegate added in v0.2.52

func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) CastDelegate() DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

func (ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec

func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
)

func (ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke

func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (panicErr error)

type DelegateAction0

type DelegateAction0 []Action0

func MakeDelegateAction0 added in v0.2.52

func MakeDelegateAction0[F ~func()](fs ...F) DelegateAction0

func (DelegateAction0) Call

func (d DelegateAction0) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool]) (panicErr error)

func (DelegateAction0) CastAction added in v0.2.52

func (d DelegateAction0) CastAction(interrupt Func1[error, bool]) Action0

func (DelegateAction0) Exec

func (d DelegateAction0) Exec(interrupt Func1[error, bool])

func (DelegateAction0) Invoke

func (d DelegateAction0) Invoke(interrupt Func1[error, bool]) (panicErr error)

type DelegateAction1

type DelegateAction1[A1 any] []Action1[A1]

func MakeDelegateAction1 added in v0.2.52

func MakeDelegateAction1[A1 any, F ~func(A1)](fs ...F) DelegateAction1[A1]

func (DelegateAction1[A1]) Call

func (d DelegateAction1[A1]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1) (panicErr error)

func (DelegateAction1[A1]) CastAction added in v0.2.52

func (d DelegateAction1[A1]) CastAction(interrupt Func1[error, bool]) Action1[A1]

func (DelegateAction1[A1]) Exec

func (d DelegateAction1[A1]) Exec(interrupt Func1[error, bool], a1 A1)

func (DelegateAction1[A1]) Invoke

func (d DelegateAction1[A1]) Invoke(interrupt Func1[error, bool], a1 A1) (panicErr error)

type DelegateAction10

type DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any] []Action10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
]

func MakeDelegateAction10 added in v0.2.52

func MakeDelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
)](fs ...F) DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

func (DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call

func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (panicErr error)

func (DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) CastAction added in v0.2.52

func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) CastAction(interrupt Func1[error, bool]) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

func (DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec

func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
)

func (DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke

func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (panicErr error)

type DelegateAction11

type DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any] []Action11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
]

func MakeDelegateAction11 added in v0.2.52

func MakeDelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
)](fs ...F) DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

func (DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call

func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (panicErr error)

func (DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) CastAction added in v0.2.52

func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) CastAction(interrupt Func1[error, bool]) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

func (DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec

func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
)

func (DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke

func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (panicErr error)

type DelegateAction12

type DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any] []Action12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
]

func MakeDelegateAction12 added in v0.2.52

func MakeDelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
)](fs ...F) DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

func (DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call

func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (panicErr error)

func (DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) CastAction added in v0.2.52

func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) CastAction(interrupt Func1[error, bool]) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

func (DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec

func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
)

func (DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke

func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (panicErr error)

type DelegateAction13

type DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any] []Action13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
]

func MakeDelegateAction13 added in v0.2.52

func MakeDelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
)](fs ...F) DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

func (DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call

func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (panicErr error)

func (DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) CastAction added in v0.2.52

func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) CastAction(interrupt Func1[error, bool]) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

func (DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec

func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
)

func (DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke

func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (panicErr error)

type DelegateAction14

type DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any] []Action14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
]

func MakeDelegateAction14 added in v0.2.52

func MakeDelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
)](fs ...F) DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

func (DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call

func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (panicErr error)

func (DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) CastAction added in v0.2.52

func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) CastAction(interrupt Func1[error, bool]) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

func (DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec

func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
)

func (DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke

func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (panicErr error)

type DelegateAction15

type DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any] []Action15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
]

func MakeDelegateAction15 added in v0.2.52

func MakeDelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
)](fs ...F) DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

func (DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call

func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (panicErr error)

func (DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) CastAction added in v0.2.52

func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) CastAction(interrupt Func1[error, bool]) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

func (DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec

func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
)

func (DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke

func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (panicErr error)

type DelegateAction16

type DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any] []Action16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
]

func MakeDelegateAction16 added in v0.2.52

func MakeDelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
)](fs ...F) DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

func (DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call

func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (panicErr error)

func (DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) CastAction added in v0.2.52

func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) CastAction(interrupt Func1[error, bool]) Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

func (DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec

func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
)

func (DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke

func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (panicErr error)

type DelegateAction2

type DelegateAction2[A1, A2 any] []Action2[A1, A2]

func MakeDelegateAction2 added in v0.2.52

func MakeDelegateAction2[A1, A2 any, F ~func(A1, A2)](fs ...F) DelegateAction2[A1, A2]

func (DelegateAction2[A1, A2]) Call

func (d DelegateAction2[A1, A2]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)

func (DelegateAction2[A1, A2]) CastAction added in v0.2.52

func (d DelegateAction2[A1, A2]) CastAction(interrupt Func1[error, bool]) Action2[A1, A2]

func (DelegateAction2[A1, A2]) Exec

func (d DelegateAction2[A1, A2]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2)

func (DelegateAction2[A1, A2]) Invoke

func (d DelegateAction2[A1, A2]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)

type DelegateAction3

type DelegateAction3[A1, A2, A3 any] []Action3[A1, A2, A3]

func MakeDelegateAction3 added in v0.2.52

func MakeDelegateAction3[A1, A2, A3 any, F ~func(A1, A2, A3)](fs ...F) DelegateAction3[A1, A2, A3]

func (DelegateAction3[A1, A2, A3]) Call

func (d DelegateAction3[A1, A2, A3]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)

func (DelegateAction3[A1, A2, A3]) CastAction added in v0.2.52

func (d DelegateAction3[A1, A2, A3]) CastAction(interrupt Func1[error, bool]) Action3[A1, A2, A3]

func (DelegateAction3[A1, A2, A3]) Exec

func (d DelegateAction3[A1, A2, A3]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3)

func (DelegateAction3[A1, A2, A3]) Invoke

func (d DelegateAction3[A1, A2, A3]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)

type DelegateAction4

type DelegateAction4[A1, A2, A3, A4 any] []Action4[A1, A2, A3, A4]

func MakeDelegateAction4 added in v0.2.52

func MakeDelegateAction4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](fs ...F) DelegateAction4[A1, A2, A3, A4]

func (DelegateAction4[A1, A2, A3, A4]) Call

func (d DelegateAction4[A1, A2, A3, A4]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)

func (DelegateAction4[A1, A2, A3, A4]) CastAction added in v0.2.52

func (d DelegateAction4[A1, A2, A3, A4]) CastAction(interrupt Func1[error, bool]) Action4[A1, A2, A3, A4]

func (DelegateAction4[A1, A2, A3, A4]) Exec

func (d DelegateAction4[A1, A2, A3, A4]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4)

func (DelegateAction4[A1, A2, A3, A4]) Invoke

func (d DelegateAction4[A1, A2, A3, A4]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)

type DelegateAction5

type DelegateAction5[A1, A2, A3, A4, A5 any] []Action5[
	A1, A2, A3, A4, A5,
]

func MakeDelegateAction5 added in v0.2.52

func MakeDelegateAction5[A1, A2, A3, A4, A5 any, F ~func(
	A1, A2, A3, A4, A5,
)](fs ...F) DelegateAction5[A1, A2, A3, A4, A5]

func (DelegateAction5[A1, A2, A3, A4, A5]) Call

func (d DelegateAction5[A1, A2, A3, A4, A5]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (panicErr error)

func (DelegateAction5[A1, A2, A3, A4, A5]) CastAction added in v0.2.52

func (d DelegateAction5[A1, A2, A3, A4, A5]) CastAction(interrupt Func1[error, bool]) Action5[A1, A2, A3, A4, A5]

func (DelegateAction5[A1, A2, A3, A4, A5]) Exec

func (d DelegateAction5[A1, A2, A3, A4, A5]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
)

func (DelegateAction5[A1, A2, A3, A4, A5]) Invoke

func (d DelegateAction5[A1, A2, A3, A4, A5]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (panicErr error)

type DelegateAction6

type DelegateAction6[A1, A2, A3, A4, A5, A6 any] []Action6[
	A1, A2, A3, A4, A5, A6,
]

func MakeDelegateAction6 added in v0.2.52

func MakeDelegateAction6[A1, A2, A3, A4, A5, A6 any, F ~func(
	A1, A2, A3, A4, A5, A6,
)](fs ...F) DelegateAction6[A1, A2, A3, A4, A5, A6]

func (DelegateAction6[A1, A2, A3, A4, A5, A6]) Call

func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (panicErr error)

func (DelegateAction6[A1, A2, A3, A4, A5, A6]) CastAction added in v0.2.52

func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) CastAction(interrupt Func1[error, bool]) Action6[A1, A2, A3, A4, A5, A6]

func (DelegateAction6[A1, A2, A3, A4, A5, A6]) Exec

func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
)

func (DelegateAction6[A1, A2, A3, A4, A5, A6]) Invoke

func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (panicErr error)

type DelegateAction7

type DelegateAction7[A1, A2, A3, A4, A5, A6, A7 any] []Action7[
	A1, A2, A3, A4, A5, A6, A7,
]

func MakeDelegateAction7 added in v0.2.52

func MakeDelegateAction7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
)](fs ...F) DelegateAction7[A1, A2, A3, A4, A5, A6, A7]

func (DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Call

func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (panicErr error)

func (DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) CastAction added in v0.2.52

func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) CastAction(interrupt Func1[error, bool]) Action7[A1, A2, A3, A4, A5, A6, A7]

func (DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Exec

func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
)

func (DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Invoke

func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (panicErr error)

type DelegateAction8

type DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8 any] []Action8[
	A1, A2, A3, A4, A5, A6, A7, A8,
]

func MakeDelegateAction8 added in v0.2.52

func MakeDelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
)](fs ...F) DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]

func (DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Call

func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (panicErr error)

func (DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) CastAction added in v0.2.52

func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) CastAction(interrupt Func1[error, bool]) Action8[A1, A2, A3, A4, A5, A6, A7, A8]

func (DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec

func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
)

func (DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke

func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (panicErr error)

type DelegateAction9

type DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any] []Action9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
]

func MakeDelegateAction9 added in v0.2.52

func MakeDelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
)](fs ...F) DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

func (DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call

func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (panicErr error)

func (DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) CastAction added in v0.2.52

func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) CastAction(interrupt Func1[error, bool]) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

func (DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec

func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
)

func (DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke

func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (panicErr error)

type DelegateActionVar0

type DelegateActionVar0[VA any] []ActionVar0[VA]

func MakeDelegateActionVar0 added in v0.2.52

func MakeDelegateActionVar0[VA any, F ~func(...VA)](fs ...F) DelegateActionVar0[VA]

func (DelegateActionVar0[VA]) Call

func (d DelegateActionVar0[VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], va ...VA) (panicErr error)

func (DelegateActionVar0[VA]) CastAction added in v0.2.52

func (d DelegateActionVar0[VA]) CastAction(interrupt Func1[error, bool]) ActionVar0[VA]

func (DelegateActionVar0[VA]) Exec

func (d DelegateActionVar0[VA]) Exec(interrupt Func1[error, bool], va ...VA)

func (DelegateActionVar0[VA]) Invoke

func (d DelegateActionVar0[VA]) Invoke(interrupt Func1[error, bool], va ...VA) (panicErr error)

type DelegateActionVar1

type DelegateActionVar1[A1, VA any] []ActionVar1[A1, VA]

func MakeDelegateActionVar1 added in v0.2.52

func MakeDelegateActionVar1[A1, VA, F ~func(A1, ...VA)](fs ...F) DelegateActionVar1[A1, VA]

func (DelegateActionVar1[A1, VA]) Call

func (d DelegateActionVar1[A1, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, va ...VA) (panicErr error)

func (DelegateActionVar1[A1, VA]) CastAction added in v0.2.52

func (d DelegateActionVar1[A1, VA]) CastAction(interrupt Func1[error, bool]) ActionVar1[A1, VA]

func (DelegateActionVar1[A1, VA]) Exec

func (d DelegateActionVar1[A1, VA]) Exec(interrupt Func1[error, bool], a1 A1, va ...VA)

func (DelegateActionVar1[A1, VA]) Invoke

func (d DelegateActionVar1[A1, VA]) Invoke(interrupt Func1[error, bool], a1 A1, va ...VA) (panicErr error)

type DelegateActionVar10

type DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any] []ActionVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA,
]

func MakeDelegateActionVar10 added in v0.2.52

func MakeDelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
)](fs ...F) DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

func (DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call

func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (panicErr error)

func (DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) CastAction added in v0.2.52

func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) CastAction(interrupt Func1[error, bool]) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

func (DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec

func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
)

func (DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke

func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (panicErr error)

type DelegateActionVar11

type DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any] []ActionVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA,
]

func MakeDelegateActionVar11 added in v0.2.52

func MakeDelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
)](fs ...F) DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

func (DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call

func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (panicErr error)

func (DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) CastAction added in v0.2.52

func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) CastAction(interrupt Func1[error, bool]) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

func (DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec

func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
)

func (DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke

func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (panicErr error)

type DelegateActionVar12

type DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any] []ActionVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA,
]

func MakeDelegateActionVar12 added in v0.2.52

func MakeDelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
)](fs ...F) DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

func (DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call

func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (panicErr error)

func (DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) CastAction added in v0.2.52

func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) CastAction(interrupt Func1[error, bool]) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

func (DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec

func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
)

func (DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke

func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (panicErr error)

type DelegateActionVar13

type DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any] []ActionVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA,
]

func MakeDelegateActionVar13 added in v0.2.52

func MakeDelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
)](fs ...F) DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

func (DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call

func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (panicErr error)

func (DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) CastAction added in v0.2.52

func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) CastAction(interrupt Func1[error, bool]) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

func (DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec

func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
)

func (DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke

func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (panicErr error)

type DelegateActionVar14

type DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any] []ActionVar14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA,
]

func MakeDelegateActionVar14 added in v0.2.52

func MakeDelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
)](fs ...F) DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

func (DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call

func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (panicErr error)

func (DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) CastAction added in v0.2.52

func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) CastAction(interrupt Func1[error, bool]) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

func (DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec

func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
)

func (DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke

func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (panicErr error)

type DelegateActionVar15

type DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any] []ActionVar15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA,
]

func MakeDelegateActionVar15 added in v0.2.52

func MakeDelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
)](fs ...F) DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

func (DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call

func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (panicErr error)

func (DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) CastAction added in v0.2.52

func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) CastAction(interrupt Func1[error, bool]) ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

func (DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec

func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
)

func (DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke

func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (panicErr error)

type DelegateActionVar16

type DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any] []ActionVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA,
]

func MakeDelegateActionVar16 added in v0.2.52

func MakeDelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
)](fs ...F) DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

func (DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call

func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (panicErr error)

func (DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) CastAction added in v0.2.52

func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) CastAction(interrupt Func1[error, bool]) ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

func (DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec

func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
)

func (DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke

func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (panicErr error)

type DelegateActionVar2

type DelegateActionVar2[A1, A2, VA any] []ActionVar2[A1, A2, VA]

func MakeDelegateActionVar2 added in v0.2.52

func MakeDelegateActionVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](fs ...F) DelegateActionVar2[A1, A2, VA]

func (DelegateActionVar2[A1, A2, VA]) Call

func (d DelegateActionVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, va ...VA) (panicErr error)

func (DelegateActionVar2[A1, A2, VA]) CastAction added in v0.2.52

func (d DelegateActionVar2[A1, A2, VA]) CastAction(interrupt Func1[error, bool]) ActionVar2[A1, A2, VA]

func (DelegateActionVar2[A1, A2, VA]) Exec

func (d DelegateActionVar2[A1, A2, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, va ...VA)

func (DelegateActionVar2[A1, A2, VA]) Invoke

func (d DelegateActionVar2[A1, A2, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, va ...VA) (panicErr error)

type DelegateActionVar3

type DelegateActionVar3[A1, A2, A3, VA any] []ActionVar3[A1, A2, A3, VA]

func MakeDelegateActionVar3 added in v0.2.52

func MakeDelegateActionVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](fs ...F) DelegateActionVar3[A1, A2, A3, VA]

func (DelegateActionVar3[A1, A2, A3, VA]) Call

func (d DelegateActionVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (panicErr error)

func (DelegateActionVar3[A1, A2, A3, VA]) CastAction added in v0.2.52

func (d DelegateActionVar3[A1, A2, A3, VA]) CastAction(interrupt Func1[error, bool]) ActionVar3[A1, A2, A3, VA]

func (DelegateActionVar3[A1, A2, A3, VA]) Exec

func (d DelegateActionVar3[A1, A2, A3, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, va ...VA)

func (DelegateActionVar3[A1, A2, A3, VA]) Invoke

func (d DelegateActionVar3[A1, A2, A3, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (panicErr error)

type DelegateActionVar4

type DelegateActionVar4[A1, A2, A3, A4, VA any] []ActionVar4[A1, A2, A3, A4, VA]

func MakeDelegateActionVar4 added in v0.2.52

func MakeDelegateActionVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](fs ...F) DelegateActionVar4[A1, A2, A3, A4, VA]

func (DelegateActionVar4[A1, A2, A3, A4, VA]) Call

func (d DelegateActionVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (panicErr error)

func (DelegateActionVar4[A1, A2, A3, A4, VA]) CastAction added in v0.2.52

func (d DelegateActionVar4[A1, A2, A3, A4, VA]) CastAction(interrupt Func1[error, bool]) ActionVar4[A1, A2, A3, A4, VA]

func (DelegateActionVar4[A1, A2, A3, A4, VA]) Exec

func (d DelegateActionVar4[A1, A2, A3, A4, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA)

func (DelegateActionVar4[A1, A2, A3, A4, VA]) Invoke

func (d DelegateActionVar4[A1, A2, A3, A4, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (panicErr error)

type DelegateActionVar5

type DelegateActionVar5[A1, A2, A3, A4, A5, VA any] []ActionVar5[
	A1, A2, A3, A4, A5, VA,
]

func MakeDelegateActionVar5 added in v0.2.52

func MakeDelegateActionVar5[A1, A2, A3, A4, A5, VA any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
)](fs ...F) DelegateActionVar5[A1, A2, A3, A4, A5, VA]

func (DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Call

func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (panicErr error)

func (DelegateActionVar5[A1, A2, A3, A4, A5, VA]) CastAction added in v0.2.52

func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) CastAction(interrupt Func1[error, bool]) ActionVar5[A1, A2, A3, A4, A5, VA]

func (DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Exec

func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
)

func (DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Invoke

func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (panicErr error)

type DelegateActionVar6

type DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA any] []ActionVar6[
	A1, A2, A3, A4, A5, A6, VA,
]

func MakeDelegateActionVar6 added in v0.2.52

func MakeDelegateActionVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
)](fs ...F) DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]

func (DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call

func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (panicErr error)

func (DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) CastAction added in v0.2.52

func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) CastAction(interrupt Func1[error, bool]) ActionVar6[A1, A2, A3, A4, A5, A6, VA]

func (DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Exec

func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
)

func (DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke

func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (panicErr error)

type DelegateActionVar7

type DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any] []ActionVar7[
	A1, A2, A3, A4, A5, A6, A7, VA,
]

func MakeDelegateActionVar7 added in v0.2.52

func MakeDelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
)](fs ...F) DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

func (DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call

func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (panicErr error)

func (DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) CastAction added in v0.2.52

func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) CastAction(interrupt Func1[error, bool]) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

func (DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec

func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
)

func (DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke

func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (panicErr error)

type DelegateActionVar8

type DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any] []ActionVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA,
]

func MakeDelegateActionVar8 added in v0.2.52

func MakeDelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
)](fs ...F) DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

func (DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call

func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (panicErr error)

func (DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) CastAction added in v0.2.52

func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) CastAction(interrupt Func1[error, bool]) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

func (DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec

func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
)

func (DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke

func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (panicErr error)

type DelegateActionVar9

type DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any] []ActionVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA,
]

func MakeDelegateActionVar9 added in v0.2.52

func MakeDelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
)](fs ...F) DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

func (DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call

func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (panicErr error)

func (DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) CastAction added in v0.2.52

func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) CastAction(interrupt Func1[error, bool]) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

func (DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec

func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
)

func (DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke

func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (panicErr error)

type DelegateFunc0

type DelegateFunc0[R any] []Func0[R]

func MakeDelegateFunc0 added in v0.2.52

func MakeDelegateFunc0[R any, F ~func() R](fs ...F) DelegateFunc0[R]

func (DelegateFunc0[R]) Call

func (d DelegateFunc0[R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool]) (r R, panicErr error)

func (DelegateFunc0[R]) CastFunc added in v0.2.52

func (d DelegateFunc0[R]) CastFunc(interrupt Func2[R, error, bool]) Func0[R]

func (DelegateFunc0[R]) Exec

func (d DelegateFunc0[R]) Exec(interrupt Func2[R, error, bool]) (r R)

func (DelegateFunc0[R]) Invoke

func (d DelegateFunc0[R]) Invoke(interrupt Func2[R, error, bool]) (r R, panicErr error)

type DelegateFunc1

type DelegateFunc1[A1, R any] []Func1[A1, R]

func MakeDelegateFunc1 added in v0.2.52

func MakeDelegateFunc1[A1, R any, F ~func(A1) R](fs ...F) DelegateFunc1[A1, R]

func (DelegateFunc1[A1, R]) Call

func (d DelegateFunc1[A1, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1) (r R, panicErr error)

func (DelegateFunc1[A1, R]) CastFunc added in v0.2.52

func (d DelegateFunc1[A1, R]) CastFunc(interrupt Func2[R, error, bool]) Func1[A1, R]

func (DelegateFunc1[A1, R]) Exec

func (d DelegateFunc1[A1, R]) Exec(interrupt Func2[R, error, bool], a1 A1) (r R)

func (DelegateFunc1[A1, R]) Invoke

func (d DelegateFunc1[A1, R]) Invoke(interrupt Func2[R, error, bool], a1 A1) (r R, panicErr error)

type DelegateFunc10

type DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any] []Func10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R,
]

func MakeDelegateFunc10 added in v0.2.52

func MakeDelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) R](fs ...F) DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

func (DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call

func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

func (DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) CastFunc added in v0.2.52

func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) CastFunc(interrupt Func2[R, error, bool]) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

func (DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec

func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R)

func (DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke

func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

type DelegateFunc11

type DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any] []Func11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R,
]

func MakeDelegateFunc11 added in v0.2.52

func MakeDelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) R](fs ...F) DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

func (DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call

func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

func (DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) CastFunc added in v0.2.52

func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) CastFunc(interrupt Func2[R, error, bool]) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

func (DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec

func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R)

func (DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke

func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

type DelegateFunc12

type DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any] []Func12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R,
]

func MakeDelegateFunc12 added in v0.2.52

func MakeDelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) R](fs ...F) DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

func (DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call

func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

func (DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) CastFunc added in v0.2.52

func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) CastFunc(interrupt Func2[R, error, bool]) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

func (DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec

func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R)

func (DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke

func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

type DelegateFunc13

type DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any] []Func13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R,
]

func MakeDelegateFunc13 added in v0.2.52

func MakeDelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) R](fs ...F) DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

func (DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call

func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

func (DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) CastFunc added in v0.2.52

func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) CastFunc(interrupt Func2[R, error, bool]) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

func (DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec

func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R)

func (DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke

func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

type DelegateFunc14

type DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any] []Func14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R,
]

func MakeDelegateFunc14 added in v0.2.52

func MakeDelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) R](fs ...F) DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

func (DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call

func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

func (DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) CastFunc added in v0.2.52

func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) CastFunc(interrupt Func2[R, error, bool]) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

func (DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec

func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R)

func (DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke

func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

type DelegateFunc15

type DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any] []Func15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R,
]

func MakeDelegateFunc15 added in v0.2.52

func MakeDelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) R](fs ...F) DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

func (DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call

func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

func (DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) CastFunc added in v0.2.52

func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) CastFunc(interrupt Func2[R, error, bool]) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

func (DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec

func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R)

func (DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke

func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

type DelegateFunc16

type DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any] []Func16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R,
]

func MakeDelegateFunc16 added in v0.2.52

func MakeDelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) R](fs ...F) DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

func (DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call

func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

func (DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) CastFunc added in v0.2.52

func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) CastFunc(interrupt Func2[R, error, bool]) Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

func (DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec

func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R)

func (DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke

func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

type DelegateFunc2

type DelegateFunc2[A1, A2, R any] []Func2[A1, A2, R]

func MakeDelegateFunc2 added in v0.2.52

func MakeDelegateFunc2[A1, A2, R any, F ~func(A1, A2) R](fs ...F) DelegateFunc2[A1, A2, R]

func (DelegateFunc2[A1, A2, R]) Call

func (d DelegateFunc2[A1, A2, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R, panicErr error)

func (DelegateFunc2[A1, A2, R]) CastFunc added in v0.2.52

func (d DelegateFunc2[A1, A2, R]) CastFunc(interrupt Func2[R, error, bool]) Func2[A1, A2, R]

func (DelegateFunc2[A1, A2, R]) Exec

func (d DelegateFunc2[A1, A2, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R)

func (DelegateFunc2[A1, A2, R]) Invoke

func (d DelegateFunc2[A1, A2, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R, panicErr error)

type DelegateFunc3

type DelegateFunc3[A1, A2, A3, R any] []Func3[A1, A2, A3, R]

func MakeDelegateFunc3 added in v0.2.52

func MakeDelegateFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](fs ...F) DelegateFunc3[A1, A2, A3, R]

func (DelegateFunc3[A1, A2, A3, R]) Call

func (d DelegateFunc3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R, panicErr error)

func (DelegateFunc3[A1, A2, A3, R]) CastFunc added in v0.2.52

func (d DelegateFunc3[A1, A2, A3, R]) CastFunc(interrupt Func2[R, error, bool]) Func3[A1, A2, A3, R]

func (DelegateFunc3[A1, A2, A3, R]) Exec

func (d DelegateFunc3[A1, A2, A3, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R)

func (DelegateFunc3[A1, A2, A3, R]) Invoke

func (d DelegateFunc3[A1, A2, A3, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R, panicErr error)

type DelegateFunc4

type DelegateFunc4[A1, A2, A3, A4, R any] []Func4[A1, A2, A3, A4, R]

func MakeDelegateFunc4 added in v0.2.52

func MakeDelegateFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](fs ...F) DelegateFunc4[A1, A2, A3, A4, R]

func (DelegateFunc4[A1, A2, A3, A4, R]) Call

func (d DelegateFunc4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

func (DelegateFunc4[A1, A2, A3, A4, R]) CastFunc added in v0.2.52

func (d DelegateFunc4[A1, A2, A3, A4, R]) CastFunc(interrupt Func2[R, error, bool]) Func4[A1, A2, A3, A4, R]

func (DelegateFunc4[A1, A2, A3, A4, R]) Exec

func (d DelegateFunc4[A1, A2, A3, A4, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R)

func (DelegateFunc4[A1, A2, A3, A4, R]) Invoke

func (d DelegateFunc4[A1, A2, A3, A4, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

type DelegateFunc5

type DelegateFunc5[A1, A2, A3, A4, A5, R any] []Func5[
	A1, A2, A3, A4, A5, R,
]

func MakeDelegateFunc5 added in v0.2.52

func MakeDelegateFunc5[A1, A2, A3, A4, A5, R any, F ~func(
	A1, A2, A3, A4, A5,
) R](fs ...F) DelegateFunc5[A1, A2, A3, A4, A5, R]

func (DelegateFunc5[A1, A2, A3, A4, A5, R]) Call

func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

func (DelegateFunc5[A1, A2, A3, A4, A5, R]) CastFunc added in v0.2.52

func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) CastFunc(interrupt Func2[R, error, bool]) Func5[A1, A2, A3, A4, A5, R]

func (DelegateFunc5[A1, A2, A3, A4, A5, R]) Exec

func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R)

func (DelegateFunc5[A1, A2, A3, A4, A5, R]) Invoke

func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

type DelegateFunc6

type DelegateFunc6[A1, A2, A3, A4, A5, A6, R any] []Func6[
	A1, A2, A3, A4, A5, A6, R,
]

func MakeDelegateFunc6 added in v0.2.52

func MakeDelegateFunc6[A1, A2, A3, A4, A5, A6, R any, F ~func(
	A1, A2, A3, A4, A5, A6,
) R](fs ...F) DelegateFunc6[A1, A2, A3, A4, A5, A6, R]

func (DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Call

func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

func (DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) CastFunc added in v0.2.52

func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) CastFunc(interrupt Func2[R, error, bool]) Func6[A1, A2, A3, A4, A5, A6, R]

func (DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Exec

func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R)

func (DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Invoke

func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

type DelegateFunc7

type DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R any] []Func7[
	A1, A2, A3, A4, A5, A6, A7, R,
]

func MakeDelegateFunc7 added in v0.2.52

func MakeDelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) R](fs ...F) DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]

func (DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Call

func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

func (DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) CastFunc added in v0.2.52

func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) CastFunc(interrupt Func2[R, error, bool]) Func7[A1, A2, A3, A4, A5, A6, A7, R]

func (DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Exec

func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R)

func (DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke

func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

type DelegateFunc8

type DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any] []Func8[
	A1, A2, A3, A4, A5, A6, A7, A8, R,
]

func MakeDelegateFunc8 added in v0.2.52

func MakeDelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) R](fs ...F) DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]

func (DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call

func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

func (DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) CastFunc added in v0.2.52

func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) CastFunc(interrupt Func2[R, error, bool]) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

func (DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec

func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R)

func (DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke

func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

type DelegateFunc9

type DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any] []Func9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, R,
]

func MakeDelegateFunc9 added in v0.2.52

func MakeDelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) R](fs ...F) DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

func (DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call

func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

func (DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) CastFunc added in v0.2.52

func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) CastFunc(interrupt Func2[R, error, bool]) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

func (DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec

func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R)

func (DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke

func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

type DelegateFuncVar0

type DelegateFuncVar0[VA, R any] []FuncVar0[VA, R]

func MakeDelegateFuncVar0 added in v0.2.52

func MakeDelegateFuncVar0[VA, R any, F ~func(...VA) R](fs ...F) DelegateFuncVar0[VA, R]

func (DelegateFuncVar0[VA, R]) Call

func (d DelegateFuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], va ...VA) (r R, panicErr error)

func (DelegateFuncVar0[VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar0[VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]

func (DelegateFuncVar0[VA, R]) Exec

func (d DelegateFuncVar0[VA, R]) Exec(interrupt Func2[R, error, bool], va ...VA) (r R)

func (DelegateFuncVar0[VA, R]) Invoke

func (d DelegateFuncVar0[VA, R]) Invoke(interrupt Func2[R, error, bool], va ...VA) (r R, panicErr error)

type DelegateFuncVar1

type DelegateFuncVar1[A1, VA, R any] []FuncVar1[A1, VA, R]

func MakeDelegateFuncVar1 added in v0.2.52

func MakeDelegateFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](fs ...F) DelegateFuncVar1[A1, VA, R]

func (DelegateFuncVar1[A1, VA, R]) Call

func (d DelegateFuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, va ...VA) (r R, panicErr error)

func (DelegateFuncVar1[A1, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar1[A1, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar1[A1, VA, R]

func (DelegateFuncVar1[A1, VA, R]) Exec

func (d DelegateFuncVar1[A1, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, va ...VA) (r R)

func (DelegateFuncVar1[A1, VA, R]) Invoke

func (d DelegateFuncVar1[A1, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, va ...VA) (r R, panicErr error)

type DelegateFuncVar10

type DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any] []FuncVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R,
]

func MakeDelegateFuncVar10 added in v0.2.52

func MakeDelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) R](fs ...F) DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

func (DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call

func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

func (DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec

func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r R)

func (DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke

func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar11

type DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any] []FuncVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R,
]

func MakeDelegateFuncVar11 added in v0.2.52

func MakeDelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) R](fs ...F) DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

func (DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call

func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

func (DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec

func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r R)

func (DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke

func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar12

type DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any] []FuncVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R,
]

func MakeDelegateFuncVar12 added in v0.2.52

func MakeDelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) R](fs ...F) DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

func (DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call

func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

func (DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec

func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r R)

func (DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke

func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar13

type DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any] []FuncVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R,
]

func MakeDelegateFuncVar13 added in v0.2.52

func MakeDelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) R](fs ...F) DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

func (DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call

func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

func (DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec

func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r R)

func (DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke

func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar14

type DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any] []FuncVar14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R,
]

func MakeDelegateFuncVar14 added in v0.2.52

func MakeDelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) R](fs ...F) DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

func (DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call

func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

func (DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec

func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r R)

func (DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke

func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar15

type DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any] []FuncVar15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R,
]

func MakeDelegateFuncVar15 added in v0.2.52

func MakeDelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) R](fs ...F) DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

func (DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call

func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

func (DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec

func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r R)

func (DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke

func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar16

type DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any] []FuncVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R,
]

func MakeDelegateFuncVar16 added in v0.2.52

func MakeDelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R](fs ...F) DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call

func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec

func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r R)

func (DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke

func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar2

type DelegateFuncVar2[A1, A2, VA, R any] []FuncVar2[A1, A2, VA, R]

func MakeDelegateFuncVar2 added in v0.2.52

func MakeDelegateFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateFuncVar2[A1, A2, VA, R]

func (DelegateFuncVar2[A1, A2, VA, R]) Call

func (d DelegateFuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, va ...VA) (r R, panicErr error)

func (DelegateFuncVar2[A1, A2, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar2[A1, A2, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]

func (DelegateFuncVar2[A1, A2, VA, R]) Exec

func (d DelegateFuncVar2[A1, A2, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, va ...VA) (r R)

func (DelegateFuncVar2[A1, A2, VA, R]) Invoke

func (d DelegateFuncVar2[A1, A2, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, va ...VA) (r R, panicErr error)

type DelegateFuncVar3

type DelegateFuncVar3[A1, A2, A3, VA, R any] []FuncVar3[A1, A2, A3, VA, R]

func MakeDelegateFuncVar3 added in v0.2.52

func MakeDelegateFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateFuncVar3[A1, A2, A3, VA, R]

func (DelegateFuncVar3[A1, A2, A3, VA, R]) Call

func (d DelegateFuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (r R, panicErr error)

func (DelegateFuncVar3[A1, A2, A3, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar3[A1, A2, A3, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]

func (DelegateFuncVar3[A1, A2, A3, VA, R]) Exec

func (d DelegateFuncVar3[A1, A2, A3, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (r R)

func (DelegateFuncVar3[A1, A2, A3, VA, R]) Invoke

func (d DelegateFuncVar3[A1, A2, A3, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (r R, panicErr error)

type DelegateFuncVar4

type DelegateFuncVar4[A1, A2, A3, A4, VA, R any] []FuncVar4[A1, A2, A3, A4, VA, R]

func MakeDelegateFuncVar4 added in v0.2.52

func MakeDelegateFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](fs ...F) DelegateFuncVar4[A1, A2, A3, A4, VA, R]

func (DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Call

func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R, panicErr error)

func (DelegateFuncVar4[A1, A2, A3, A4, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]

func (DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Exec

func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R)

func (DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Invoke

func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R, panicErr error)

type DelegateFuncVar5

type DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R any] []FuncVar5[
	A1, A2, A3, A4, A5, VA, R,
]

func MakeDelegateFuncVar5 added in v0.2.52

func MakeDelegateFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) R](fs ...F) DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]

func (DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Call

func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]

func (DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec

func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r R)

func (DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke

func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar6

type DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any] []FuncVar6[
	A1, A2, A3, A4, A5, A6, VA, R,
]

func MakeDelegateFuncVar6 added in v0.2.52

func MakeDelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R](fs ...F) DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call

func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec

func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r R)

func (DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke

func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar7

type DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any] []FuncVar7[
	A1, A2, A3, A4, A5, A6, A7, VA, R,
]

func MakeDelegateFuncVar7 added in v0.2.52

func MakeDelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R](fs ...F) DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call

func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec

func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r R)

func (DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke

func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar8

type DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any] []FuncVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA, R,
]

func MakeDelegateFuncVar8 added in v0.2.52

func MakeDelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R](fs ...F) DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call

func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec

func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r R)

func (DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke

func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r R, panicErr error)

type DelegateFuncVar9

type DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any] []FuncVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R,
]

func MakeDelegateFuncVar9 added in v0.2.52

func MakeDelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R](fs ...F) DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call

func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r R, panicErr error)

func (DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) CastFunc added in v0.2.52

func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec

func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r R)

func (DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke

func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r R, panicErr error)

type DelegatePairFunc0

type DelegatePairFunc0[R1, R2 any] []PairFunc0[R1, R2]

func MakeDelegatePairFunc0 added in v0.2.52

func MakeDelegatePairFunc0[R1, R2 any, F ~func() (R1, R2)](fs ...F) DelegatePairFunc0[R1, R2]

func (DelegatePairFunc0[R1, R2]) Call

func (d DelegatePairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc0[R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc0[R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc0[R1, R2]

func (DelegatePairFunc0[R1, R2]) Exec

func (d DelegatePairFunc0[R1, R2]) Exec(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2)

func (DelegatePairFunc0[R1, R2]) Invoke

func (d DelegatePairFunc0[R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc1

type DelegatePairFunc1[A1, R1, R2 any] []PairFunc1[A1, R1, R2]

func MakeDelegatePairFunc1 added in v0.2.52

func MakeDelegatePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](fs ...F) DelegatePairFunc1[A1, R1, R2]

func (DelegatePairFunc1[A1, R1, R2]) Call

func (d DelegatePairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc1[A1, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc1[A1, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc1[A1, R1, R2]

func (DelegatePairFunc1[A1, R1, R2]) Exec

func (d DelegatePairFunc1[A1, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2)

func (DelegatePairFunc1[A1, R1, R2]) Invoke

func (d DelegatePairFunc1[A1, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc10

type DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any] []PairFunc10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2,
]

func MakeDelegatePairFunc10 added in v0.2.52

func MakeDelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)](fs ...F) DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

func (DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call

func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

func (DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec

func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2)

func (DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke

func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc11

type DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any] []PairFunc11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2,
]

func MakeDelegatePairFunc11 added in v0.2.52

func MakeDelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)](fs ...F) DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

func (DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call

func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

func (DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec

func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2)

func (DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke

func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc12

type DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any] []PairFunc12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2,
]

func MakeDelegatePairFunc12 added in v0.2.52

func MakeDelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)](fs ...F) DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

func (DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call

func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

func (DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec

func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2)

func (DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke

func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc13

type DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any] []PairFunc13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2,
]

func MakeDelegatePairFunc13 added in v0.2.52

func MakeDelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)](fs ...F) DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

func (DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call

func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

func (DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec

func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2)

func (DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke

func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc14

type DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any] []PairFunc14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2,
]

func MakeDelegatePairFunc14 added in v0.2.52

func MakeDelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)](fs ...F) DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

func (DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call

func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

func (DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec

func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2)

func (DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke

func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc15

type DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any] []PairFunc15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2,
]

func MakeDelegatePairFunc15 added in v0.2.52

func MakeDelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)](fs ...F) DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

func (DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call

func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

func (DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec

func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2)

func (DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke

func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc16

type DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any] []PairFunc16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2,
]

func MakeDelegatePairFunc16 added in v0.2.52

func MakeDelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)](fs ...F) DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

func (DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call

func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

func (DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec

func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2)

func (DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke

func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc2

type DelegatePairFunc2[A1, A2, R1, R2 any] []PairFunc2[A1, A2, R1, R2]

func MakeDelegatePairFunc2 added in v0.2.52

func MakeDelegatePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](fs ...F) DelegatePairFunc2[A1, A2, R1, R2]

func (DelegatePairFunc2[A1, A2, R1, R2]) Call

func (d DelegatePairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc2[A1, A2, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc2[A1, A2, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc2[A1, A2, R1, R2]

func (DelegatePairFunc2[A1, A2, R1, R2]) Exec

func (d DelegatePairFunc2[A1, A2, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2)

func (DelegatePairFunc2[A1, A2, R1, R2]) Invoke

func (d DelegatePairFunc2[A1, A2, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc3

type DelegatePairFunc3[A1, A2, A3, R1, R2 any] []PairFunc3[A1, A2, A3, R1, R2]

func MakeDelegatePairFunc3 added in v0.2.52

func MakeDelegatePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](fs ...F) DelegatePairFunc3[A1, A2, A3, R1, R2]

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) Call

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc3[A1, A2, A3, R1, R2]

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) Exec

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) Invoke

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc4

type DelegatePairFunc4[A1, A2, A3, A4, R1, R2 any] []PairFunc4[A1, A2, A3, A4, R1, R2]

func MakeDelegatePairFunc4 added in v0.2.52

func MakeDelegatePairFunc4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](fs ...F) DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Call

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc4[A1, A2, A3, A4, R1, R2]

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Exec

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Invoke

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc5

type DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2 any] []PairFunc5[
	A1, A2, A3, A4, A5, R1, R2,
]

func MakeDelegatePairFunc5 added in v0.2.52

func MakeDelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5,
) (R1, R2)](fs ...F) DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc5[A1, A2, A3, A4, A5, R1, R2]

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2)

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc6

type DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any] []PairFunc6[
	A1, A2, A3, A4, A5, A6, R1, R2,
]

func MakeDelegatePairFunc6 added in v0.2.52

func MakeDelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)](fs ...F) DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2)

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc7

type DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any] []PairFunc7[
	A1, A2, A3, A4, A5, A6, A7, R1, R2,
]

func MakeDelegatePairFunc7 added in v0.2.52

func MakeDelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)](fs ...F) DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2)

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc8

type DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any] []PairFunc8[
	A1, A2, A3, A4, A5, A6, A7, A8, R1, R2,
]

func MakeDelegatePairFunc8 added in v0.2.52

func MakeDelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)](fs ...F) DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2)

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFunc9

type DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any] []PairFunc9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2,
]

func MakeDelegatePairFunc9 added in v0.2.52

func MakeDelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)](fs ...F) DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2)

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar0

type DelegatePairFuncVar0[VA, R1, R2 any] []PairFuncVar0[VA, R1, R2]

func MakeDelegatePairFuncVar0 added in v0.2.52

func MakeDelegatePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairFuncVar0[VA, R1, R2]

func (DelegatePairFuncVar0[VA, R1, R2]) Call

func (d DelegatePairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], va ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar0[VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar0[VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar0[VA, R1, R2]

func (DelegatePairFuncVar0[VA, R1, R2]) Exec

func (d DelegatePairFuncVar0[VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], va ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar0[VA, R1, R2]) Invoke

func (d DelegatePairFuncVar0[VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], va ...VA) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar1

type DelegatePairFuncVar1[A1, VA, R1, R2 any] []PairFuncVar1[A1, VA, R1, R2]

func MakeDelegatePairFuncVar1 added in v0.2.52

func MakeDelegatePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar1[A1, VA, R1, R2]

func (DelegatePairFuncVar1[A1, VA, R1, R2]) Call

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, va ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar1[A1, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar1[A1, VA, R1, R2]

func (DelegatePairFuncVar1[A1, VA, R1, R2]) Exec

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, va ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar1[A1, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, va ...VA) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar10

type DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any] []PairFuncVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2,
]

func MakeDelegatePairFuncVar10 added in v0.2.52

func MakeDelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar11

type DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any] []PairFuncVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2,
]

func MakeDelegatePairFuncVar11 added in v0.2.52

func MakeDelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar12

type DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any] []PairFuncVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2,
]

func MakeDelegatePairFuncVar12 added in v0.2.52

func MakeDelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar13

type DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any] []PairFuncVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2,
]

func MakeDelegatePairFuncVar13 added in v0.2.52

func MakeDelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar14

type DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any] []PairFuncVar14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2,
]

func MakeDelegatePairFuncVar14 added in v0.2.52

func MakeDelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar15

type DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any] []PairFuncVar15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2,
]

func MakeDelegatePairFuncVar15 added in v0.2.52

func MakeDelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar16

type DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any] []PairFuncVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2,
]

func MakeDelegatePairFuncVar16 added in v0.2.52

func MakeDelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar2

type DelegatePairFuncVar2[A1, A2, VA, R1, R2 any] []PairFuncVar2[A1, A2, VA, R1, R2]

func MakeDelegatePairFuncVar2 added in v0.2.52

func MakeDelegatePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar2[A1, A2, VA, R1, R2]

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Call

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar2[A1, A2, VA, R1, R2]

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Exec

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar3

type DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2 any] []PairFuncVar3[A1, A2, A3, VA, R1, R2]

func MakeDelegatePairFuncVar3 added in v0.2.52

func MakeDelegatePairFuncVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Call

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar3[A1, A2, A3, VA, R1, R2]

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar4

type DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any] []PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func MakeDelegatePairFuncVar4 added in v0.2.52

func MakeDelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar5

type DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any] []PairFuncVar5[
	A1, A2, A3, A4, A5, VA, R1, R2,
]

func MakeDelegatePairFuncVar5 added in v0.2.52

func MakeDelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar6

type DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any] []PairFuncVar6[
	A1, A2, A3, A4, A5, A6, VA, R1, R2,
]

func MakeDelegatePairFuncVar6 added in v0.2.52

func MakeDelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar7

type DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any] []PairFuncVar7[
	A1, A2, A3, A4, A5, A6, A7, VA, R1, R2,
]

func MakeDelegatePairFuncVar7 added in v0.2.52

func MakeDelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar8

type DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any] []PairFuncVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2,
]

func MakeDelegatePairFuncVar8 added in v0.2.52

func MakeDelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type DelegatePairFuncVar9

type DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any] []PairFuncVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2,
]

func MakeDelegatePairFuncVar9 added in v0.2.52

func MakeDelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) CastFunc added in v0.2.52

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type Func0

type Func0[R any] func() R

func MakeFunc0 added in v0.2.52

func MakeFunc0[R any, F ~func() R](f F) Func0[R]

func (Func0[R]) Call

func (f Func0[R]) Call(autoRecover bool, reportError chan error) (r R, panicErr error)

func (Func0[R]) CastDelegate added in v0.2.52

func (f Func0[R]) CastDelegate() DelegateFunc0[R]

func (Func0[R]) Exec

func (f Func0[R]) Exec() (r R)

func (Func0[R]) Invoke

func (f Func0[R]) Invoke() (r R, panicErr error)

type Func1

type Func1[A1, R any] func(A1) R

func MakeFunc1 added in v0.2.52

func MakeFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]

func (Func1[A1, R]) Call

func (f Func1[A1, R]) Call(autoRecover bool, reportError chan error, a1 A1) (r R, panicErr error)

func (Func1[A1, R]) CastDelegate added in v0.2.52

func (f Func1[A1, R]) CastDelegate() DelegateFunc1[A1, R]

func (Func1[A1, R]) Exec

func (f Func1[A1, R]) Exec(a1 A1) (r R)

func (Func1[A1, R]) Invoke

func (f Func1[A1, R]) Invoke(a1 A1) (r R, panicErr error)

type Func10

type Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) R

func MakeFunc10 added in v0.2.52

func MakeFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) R](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) CastDelegate added in v0.2.52

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) CastDelegate() DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R)

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

type Func11

type Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) R

func MakeFunc11 added in v0.2.52

func MakeFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) R](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) CastDelegate added in v0.2.52

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) CastDelegate() DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R)

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

type Func12

type Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) R

func MakeFunc12 added in v0.2.52

func MakeFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) R](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) CastDelegate added in v0.2.52

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) CastDelegate() DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R)

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

type Func13

type Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) R

func MakeFunc13 added in v0.2.52

func MakeFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) R](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) CastDelegate added in v0.2.52

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) CastDelegate() DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R)

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

type Func14

type Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) R

func MakeFunc14 added in v0.2.52

func MakeFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) R](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) CastDelegate added in v0.2.52

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) CastDelegate() DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R)

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

type Func15

type Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) R

func MakeFunc15 added in v0.2.52

func MakeFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) R](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) CastDelegate added in v0.2.52

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) CastDelegate() DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R)

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

type Func16

type Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) R

func MakeFunc16 added in v0.2.52

func MakeFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) R](f F) Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) CastDelegate added in v0.2.52

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) CastDelegate() DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R)

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

type Func2

type Func2[A1, A2, R any] func(A1, A2) R

func MakeFunc2 added in v0.2.52

func MakeFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]

func (Func2[A1, A2, R]) Call

func (f Func2[A1, A2, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r R, panicErr error)

func (Func2[A1, A2, R]) CastDelegate added in v0.2.52

func (f Func2[A1, A2, R]) CastDelegate() DelegateFunc2[A1, A2, R]

func (Func2[A1, A2, R]) Exec

func (f Func2[A1, A2, R]) Exec(a1 A1, a2 A2) (r R)

func (Func2[A1, A2, R]) Invoke

func (f Func2[A1, A2, R]) Invoke(a1 A1, a2 A2) (r R, panicErr error)

type Func3

type Func3[A1, A2, A3, R any] func(A1, A2, A3) R

func MakeFunc3 added in v0.2.52

func MakeFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]

func (Func3[A1, A2, A3, R]) Call

func (f Func3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r R, panicErr error)

func (Func3[A1, A2, A3, R]) CastDelegate added in v0.2.52

func (f Func3[A1, A2, A3, R]) CastDelegate() DelegateFunc3[A1, A2, A3, R]

func (Func3[A1, A2, A3, R]) Exec

func (f Func3[A1, A2, A3, R]) Exec(a1 A1, a2 A2, a3 A3) (r R)

func (Func3[A1, A2, A3, R]) Invoke

func (f Func3[A1, A2, A3, R]) Invoke(a1 A1, a2 A2, a3 A3) (r R, panicErr error)

type Func4

type Func4[A1, A2, A3, A4, R any] func(A1, A2, A3, A4) R

func MakeFunc4 added in v0.2.52

func MakeFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]

func (Func4[A1, A2, A3, A4, R]) Call

func (f Func4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

func (Func4[A1, A2, A3, A4, R]) CastDelegate added in v0.2.52

func (f Func4[A1, A2, A3, A4, R]) CastDelegate() DelegateFunc4[A1, A2, A3, A4, R]

func (Func4[A1, A2, A3, A4, R]) Exec

func (f Func4[A1, A2, A3, A4, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r R)

func (Func4[A1, A2, A3, A4, R]) Invoke

func (f Func4[A1, A2, A3, A4, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

type Func5

type Func5[A1, A2, A3, A4, A5, R any] func(
	A1, A2, A3, A4, A5,
) R

func MakeFunc5 added in v0.2.52

func MakeFunc5[A1, A2, A3, A4, A5, R any, F ~func(
	A1, A2, A3, A4, A5,
) R](f F) Func5[A1, A2, A3, A4, A5, R]

func (Func5[A1, A2, A3, A4, A5, R]) Call

func (f Func5[A1, A2, A3, A4, A5, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

func (Func5[A1, A2, A3, A4, A5, R]) CastDelegate added in v0.2.52

func (f Func5[A1, A2, A3, A4, A5, R]) CastDelegate() DelegateFunc5[A1, A2, A3, A4, A5, R]

func (Func5[A1, A2, A3, A4, A5, R]) Exec

func (f Func5[A1, A2, A3, A4, A5, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R)

func (Func5[A1, A2, A3, A4, A5, R]) Invoke

func (f Func5[A1, A2, A3, A4, A5, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

type Func6

type Func6[A1, A2, A3, A4, A5, A6, R any] func(
	A1, A2, A3, A4, A5, A6,
) R

func MakeFunc6 added in v0.2.52

func MakeFunc6[A1, A2, A3, A4, A5, A6, R any, F ~func(
	A1, A2, A3, A4, A5, A6,
) R](f F) Func6[A1, A2, A3, A4, A5, A6, R]

func (Func6[A1, A2, A3, A4, A5, A6, R]) Call

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

func (Func6[A1, A2, A3, A4, A5, A6, R]) CastDelegate added in v0.2.52

func (f Func6[A1, A2, A3, A4, A5, A6, R]) CastDelegate() DelegateFunc6[A1, A2, A3, A4, A5, A6, R]

func (Func6[A1, A2, A3, A4, A5, A6, R]) Exec

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R)

func (Func6[A1, A2, A3, A4, A5, A6, R]) Invoke

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

type Func7

type Func7[A1, A2, A3, A4, A5, A6, A7, R any] func(
	A1, A2, A3, A4, A5, A6, A7,
) R

func MakeFunc7 added in v0.2.52

func MakeFunc7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) R](f F) Func7[A1, A2, A3, A4, A5, A6, A7, R]

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Call

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) CastDelegate added in v0.2.52

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) CastDelegate() DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Exec

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R)

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

type Func8

type Func8[A1, A2, A3, A4, A5, A6, A7, A8, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) R

func MakeFunc8 added in v0.2.52

func MakeFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) R](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) CastDelegate added in v0.2.52

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) CastDelegate() DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R)

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

type Func9

type Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) R

func MakeFunc9 added in v0.2.52

func MakeFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) R](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) CastDelegate added in v0.2.52

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) CastDelegate() DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R)

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

type FuncVar0

type FuncVar0[VA, R any] func(...VA) R

func MakeFuncVar0 added in v0.2.52

func MakeFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]

func (FuncVar0[VA, R]) Call

func (f FuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, va ...VA) (r R, panicErr error)

func (FuncVar0[VA, R]) CastDelegate added in v0.2.52

func (f FuncVar0[VA, R]) CastDelegate() DelegateFuncVar0[VA, R]

func (FuncVar0[VA, R]) Exec

func (f FuncVar0[VA, R]) Exec(va ...VA) (r R)

func (FuncVar0[VA, R]) Invoke

func (f FuncVar0[VA, R]) Invoke(va ...VA) (r R, panicErr error)

type FuncVar1

type FuncVar1[A1, VA, R any] func(A1, ...VA) R

func MakeFuncVar1 added in v0.2.52

func MakeFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]

func (FuncVar1[A1, VA, R]) Call

func (f FuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, va ...VA) (r R, panicErr error)

func (FuncVar1[A1, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar1[A1, VA, R]) CastDelegate() DelegateFuncVar1[A1, VA, R]

func (FuncVar1[A1, VA, R]) Exec

func (f FuncVar1[A1, VA, R]) Exec(a1 A1, va ...VA) (r R)

func (FuncVar1[A1, VA, R]) Invoke

func (f FuncVar1[A1, VA, R]) Invoke(a1 A1, va ...VA) (r R, panicErr error)

type FuncVar10

type FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) R

func MakeFuncVar10 added in v0.2.52

func MakeFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) R](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r R, panicErr error)

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) CastDelegate() DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r R)

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r R, panicErr error)

type FuncVar11

type FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) R

func MakeFuncVar11 added in v0.2.52

func MakeFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) R](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r R, panicErr error)

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) CastDelegate() DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r R)

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r R, panicErr error)

type FuncVar12

type FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) R

func MakeFuncVar12 added in v0.2.52

func MakeFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) R](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r R, panicErr error)

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) CastDelegate() DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r R)

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r R, panicErr error)

type FuncVar13

type FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) R

func MakeFuncVar13 added in v0.2.52

func MakeFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) R](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r R, panicErr error)

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) CastDelegate() DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r R)

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r R, panicErr error)

type FuncVar14

type FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) R

func MakeFuncVar14 added in v0.2.52

func MakeFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) R](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r R, panicErr error)

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) CastDelegate() DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r R)

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r R, panicErr error)

type FuncVar15

type FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) R

func MakeFuncVar15 added in v0.2.52

func MakeFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) R](f F) FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r R, panicErr error)

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) CastDelegate() DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r R)

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r R, panicErr error)

type FuncVar16

type FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R

func MakeFuncVar16 added in v0.2.52

func MakeFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R](f F) FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r R, panicErr error)

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) CastDelegate() DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r R)

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r R, panicErr error)

type FuncVar2

type FuncVar2[A1, A2, VA, R any] func(A1, A2, ...VA) R

func MakeFuncVar2 added in v0.2.52

func MakeFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](f F) FuncVar2[A1, A2, VA, R]

func (FuncVar2[A1, A2, VA, R]) Call

func (f FuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, va ...VA) (r R, panicErr error)

func (FuncVar2[A1, A2, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar2[A1, A2, VA, R]) CastDelegate() DelegateFuncVar2[A1, A2, VA, R]

func (FuncVar2[A1, A2, VA, R]) Exec

func (f FuncVar2[A1, A2, VA, R]) Exec(a1 A1, a2 A2, va ...VA) (r R)

func (FuncVar2[A1, A2, VA, R]) Invoke

func (f FuncVar2[A1, A2, VA, R]) Invoke(a1 A1, a2 A2, va ...VA) (r R, panicErr error)

type FuncVar3

type FuncVar3[A1, A2, A3, VA, R any] func(A1, A2, A3, ...VA) R

func MakeFuncVar3 added in v0.2.52

func MakeFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]

func (FuncVar3[A1, A2, A3, VA, R]) Call

func (f FuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, va ...VA) (r R, panicErr error)

func (FuncVar3[A1, A2, A3, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar3[A1, A2, A3, VA, R]) CastDelegate() DelegateFuncVar3[A1, A2, A3, VA, R]

func (FuncVar3[A1, A2, A3, VA, R]) Exec

func (f FuncVar3[A1, A2, A3, VA, R]) Exec(a1 A1, a2 A2, a3 A3, va ...VA) (r R)

func (FuncVar3[A1, A2, A3, VA, R]) Invoke

func (f FuncVar3[A1, A2, A3, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, va ...VA) (r R, panicErr error)

type FuncVar4

type FuncVar4[A1, A2, A3, A4, VA, R any] func(A1, A2, A3, A4, ...VA) R

func MakeFuncVar4 added in v0.2.52

func MakeFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](f F) FuncVar4[A1, A2, A3, A4, VA, R]

func (FuncVar4[A1, A2, A3, A4, VA, R]) Call

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R, panicErr error)

func (FuncVar4[A1, A2, A3, A4, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar4[A1, A2, A3, A4, VA, R]) CastDelegate() DelegateFuncVar4[A1, A2, A3, A4, VA, R]

func (FuncVar4[A1, A2, A3, A4, VA, R]) Exec

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R)

func (FuncVar4[A1, A2, A3, A4, VA, R]) Invoke

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R, panicErr error)

type FuncVar5

type FuncVar5[A1, A2, A3, A4, A5, VA, R any] func(
	A1, A2, A3, A4, A5, ...VA,
) R

func MakeFuncVar5 added in v0.2.52

func MakeFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) R](f F) FuncVar5[A1, A2, A3, A4, A5, VA, R]

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Call

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r R, panicErr error)

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) CastDelegate() DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r R)

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r R, panicErr error)

type FuncVar6

type FuncVar6[A1, A2, A3, A4, A5, A6, VA, R any] func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R

func MakeFuncVar6 added in v0.2.52

func MakeFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R](f F) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r R, panicErr error)

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) CastDelegate() DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r R)

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r R, panicErr error)

type FuncVar7

type FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R

func MakeFuncVar7 added in v0.2.52

func MakeFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r R, panicErr error)

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) CastDelegate() DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r R)

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r R, panicErr error)

type FuncVar8

type FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R

func MakeFuncVar8 added in v0.2.52

func MakeFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r R, panicErr error)

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) CastDelegate() DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r R)

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r R, panicErr error)

type FuncVar9

type FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R

func MakeFuncVar9 added in v0.2.52

func MakeFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r R, panicErr error)

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) CastDelegate added in v0.2.52

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) CastDelegate() DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r R)

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r R, panicErr error)

type PairFunc0

type PairFunc0[R1, R2 any] func() (R1, R2)

func MakePairFunc0 added in v0.2.52

func MakePairFunc0[R1, R2 any, F ~func() (R1, R2)](f F) PairFunc0[R1, R2]

func (PairFunc0[R1, R2]) Call

func (f PairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)

func (PairFunc0[R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc0[R1, R2]) CastDelegate() DelegatePairFunc0[R1, R2]

func (PairFunc0[R1, R2]) Exec

func (f PairFunc0[R1, R2]) Exec() (r1 R1, r2 R2)

func (PairFunc0[R1, R2]) Invoke

func (f PairFunc0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)

type PairFunc1

type PairFunc1[A1, R1, R2 any] func(A1) (R1, R2)

func MakePairFunc1 added in v0.2.52

func MakePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) PairFunc1[A1, R1, R2]

func (PairFunc1[A1, R1, R2]) Call

func (f PairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)

func (PairFunc1[A1, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc1[A1, R1, R2]) CastDelegate() DelegatePairFunc1[A1, R1, R2]

func (PairFunc1[A1, R1, R2]) Exec

func (f PairFunc1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)

func (PairFunc1[A1, R1, R2]) Invoke

func (f PairFunc1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)

type PairFunc10

type PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)

func MakePairFunc10 added in v0.2.52

func MakePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)](f F) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) CastDelegate() DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2)

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

type PairFunc11

type PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)

func MakePairFunc11 added in v0.2.52

func MakePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)](f F) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) CastDelegate() DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2)

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

type PairFunc12

type PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)

func MakePairFunc12 added in v0.2.52

func MakePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)](f F) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) CastDelegate() DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2)

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

type PairFunc13

type PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)

func MakePairFunc13 added in v0.2.52

func MakePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)](f F) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) CastDelegate() DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2)

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

type PairFunc14

type PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)

func MakePairFunc14 added in v0.2.52

func MakePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)](f F) PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) CastDelegate() DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2)

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

type PairFunc15

type PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)

func MakePairFunc15 added in v0.2.52

func MakePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)](f F) PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) CastDelegate() DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2)

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

type PairFunc16

type PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)

func MakePairFunc16 added in v0.2.52

func MakePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)](f F) PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) CastDelegate() DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2)

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

type PairFunc2

type PairFunc2[A1, A2, R1, R2 any] func(A1, A2) (R1, R2)

func MakePairFunc2 added in v0.2.52

func MakePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) PairFunc2[A1, A2, R1, R2]

func (PairFunc2[A1, A2, R1, R2]) Call

func (f PairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (PairFunc2[A1, A2, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc2[A1, A2, R1, R2]) CastDelegate() DelegatePairFunc2[A1, A2, R1, R2]

func (PairFunc2[A1, A2, R1, R2]) Exec

func (f PairFunc2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)

func (PairFunc2[A1, A2, R1, R2]) Invoke

func (f PairFunc2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

type PairFunc3

type PairFunc3[A1, A2, A3, R1, R2 any] func(A1, A2, A3) (R1, R2)

func MakePairFunc3 added in v0.2.52

func MakePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) PairFunc3[A1, A2, A3, R1, R2]

func (PairFunc3[A1, A2, A3, R1, R2]) Call

func (f PairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (PairFunc3[A1, A2, A3, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc3[A1, A2, A3, R1, R2]) CastDelegate() DelegatePairFunc3[A1, A2, A3, R1, R2]

func (PairFunc3[A1, A2, A3, R1, R2]) Exec

func (f PairFunc3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

func (PairFunc3[A1, A2, A3, R1, R2]) Invoke

func (f PairFunc3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

type PairFunc4

type PairFunc4[A1, A2, A3, A4, R1, R2 any] func(A1, A2, A3, A4) (R1, R2)

func MakePairFunc4 added in v0.2.52

func MakePairFunc4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](f F) PairFunc4[A1, A2, A3, A4, R1, R2]

func (PairFunc4[A1, A2, A3, A4, R1, R2]) Call

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (PairFunc4[A1, A2, A3, A4, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) CastDelegate() DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

func (PairFunc4[A1, A2, A3, A4, R1, R2]) Exec

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

func (PairFunc4[A1, A2, A3, A4, R1, R2]) Invoke

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

type PairFunc5

type PairFunc5[A1, A2, A3, A4, A5, R1, R2 any] func(
	A1, A2, A3, A4, A5,
) (R1, R2)

func MakePairFunc5 added in v0.2.52

func MakePairFunc5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5,
) (R1, R2)](f F) PairFunc5[A1, A2, A3, A4, A5, R1, R2]

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) CastDelegate() DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2)

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

type PairFunc6

type PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)

func MakePairFunc6 added in v0.2.52

func MakePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)](f F) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) CastDelegate() DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2)

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

type PairFunc7

type PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)

func MakePairFunc7 added in v0.2.52

func MakePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)](f F) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) CastDelegate() DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2)

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

type PairFunc8

type PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)

func MakePairFunc8 added in v0.2.52

func MakePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)](f F) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) CastDelegate() DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2)

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

type PairFunc9

type PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)

func MakePairFunc9 added in v0.2.52

func MakePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)](f F) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) CastDelegate added in v0.2.52

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) CastDelegate() DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2)

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar0

type PairFuncVar0[VA, R1, R2 any] func(...VA) (R1, R2)

func MakePairFuncVar0 added in v0.2.52

func MakePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) PairFuncVar0[VA, R1, R2]

func (PairFuncVar0[VA, R1, R2]) Call

func (f PairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, va ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar0[VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar0[VA, R1, R2]) CastDelegate() DelegatePairFuncVar0[VA, R1, R2]

func (PairFuncVar0[VA, R1, R2]) Exec

func (f PairFuncVar0[VA, R1, R2]) Exec(va ...VA) (r1 R1, r2 R2)

func (PairFuncVar0[VA, R1, R2]) Invoke

func (f PairFuncVar0[VA, R1, R2]) Invoke(va ...VA) (r1 R1, r2 R2, panicErr error)

type PairFuncVar1

type PairFuncVar1[A1, VA, R1, R2 any] func(A1, ...VA) (R1, R2)

func MakePairFuncVar1 added in v0.2.52

func MakePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) PairFuncVar1[A1, VA, R1, R2]

func (PairFuncVar1[A1, VA, R1, R2]) Call

func (f PairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, va ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar1[A1, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar1[A1, VA, R1, R2]) CastDelegate() DelegatePairFuncVar1[A1, VA, R1, R2]

func (PairFuncVar1[A1, VA, R1, R2]) Exec

func (f PairFuncVar1[A1, VA, R1, R2]) Exec(a1 A1, va ...VA) (r1 R1, r2 R2)

func (PairFuncVar1[A1, VA, R1, R2]) Invoke

func (f PairFuncVar1[A1, VA, R1, R2]) Invoke(a1 A1, va ...VA) (r1 R1, r2 R2, panicErr error)

type PairFuncVar10

type PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)

func MakePairFuncVar10 added in v0.2.52

func MakePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)](f F) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) CastDelegate() DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar11

type PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)

func MakePairFuncVar11 added in v0.2.52

func MakePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)](f F) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) CastDelegate() DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar12

type PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)

func MakePairFuncVar12 added in v0.2.52

func MakePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)](f F) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) CastDelegate() DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar13

type PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)

func MakePairFuncVar13 added in v0.2.52

func MakePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)](f F) PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) CastDelegate() DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar14

type PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)

func MakePairFuncVar14 added in v0.2.52

func MakePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)](f F) PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) CastDelegate() DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar15

type PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)

func MakePairFuncVar15 added in v0.2.52

func MakePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)](f F) PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) CastDelegate() DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar16

type PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)

func MakePairFuncVar16 added in v0.2.52

func MakePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)](f F) PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) CastDelegate() DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar2

type PairFuncVar2[A1, A2, VA, R1, R2 any] func(A1, A2, ...VA) (R1, R2)

func MakePairFuncVar2 added in v0.2.52

func MakePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) PairFuncVar2[A1, A2, VA, R1, R2]

func (PairFuncVar2[A1, A2, VA, R1, R2]) Call

func (f PairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar2[A1, A2, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar2[A1, A2, VA, R1, R2]) CastDelegate() DelegatePairFuncVar2[A1, A2, VA, R1, R2]

func (PairFuncVar2[A1, A2, VA, R1, R2]) Exec

func (f PairFuncVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2)

func (PairFuncVar2[A1, A2, VA, R1, R2]) Invoke

func (f PairFuncVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2, panicErr error)

type PairFuncVar3

type PairFuncVar3[A1, A2, A3, VA, R1, R2 any] func(A1, A2, A3, ...VA) (R1, R2)

func MakePairFuncVar3 added in v0.2.52

func MakePairFuncVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](f F) PairFuncVar3[A1, A2, A3, VA, R1, R2]

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) Call

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) CastDelegate() DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2)

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2, panicErr error)

type PairFuncVar4

type PairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any] func(A1, A2, A3, A4, ...VA) (R1, R2)

func MakePairFuncVar4 added in v0.2.52

func MakePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](f F) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) CastDelegate() DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r1 R1, r2 R2)

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r1 R1, r2 R2, panicErr error)

type PairFuncVar5

type PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)

func MakePairFuncVar5 added in v0.2.52

func MakePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)](f F) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) CastDelegate() DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar6

type PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)

func MakePairFuncVar6 added in v0.2.52

func MakePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)](f F) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) CastDelegate() DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar7

type PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)

func MakePairFuncVar7 added in v0.2.52

func MakePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)](f F) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) CastDelegate() DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar8

type PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)

func MakePairFuncVar8 added in v0.2.52

func MakePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)](f F) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) CastDelegate() DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, va ...VA,
) (r1 R1, r2 R2, panicErr error)

type PairFuncVar9

type PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)

func MakePairFuncVar9 added in v0.2.52

func MakePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)](f F) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) CastDelegate added in v0.2.52

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) CastDelegate() DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, va ...VA,
) (r1 R1, r2 R2, panicErr error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL