generic

package

Go to main page

Versions in this module

v0

v0.3.91

Jan 17, 2025

v0.3.90

Jan 17, 2025

v0.3.89

Jan 17, 2025

Changes in this version

type Action0

+ func (f Action0) SafeCall() (panicErr error)

+ func (f Action0) UnsafeCall()

type Action1

+ func (f Action1[A1]) SafeCall(a1 A1) (panicErr error)

+ func (f Action1[A1]) UnsafeCall(a1 A1)

type Action10

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

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

type Action11

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

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

type Action12

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

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

type Action13

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

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

type Action14

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

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

type Action15

+ func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (panicErr error)

+ func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...)

type Action16

+ func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (panicErr error)

+ func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...)

type Action2

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

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

type Action3

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

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

type Action4

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

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

type Action5

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

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

type Action6

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

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

type Action7

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

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

type Action8

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

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

type Action9

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

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

type ActionVar0

+ func (f ActionVar0[VA]) SafeCall(args ...VA) (panicErr error)

+ func (f ActionVar0[VA]) UnsafeCall(args ...VA)

type ActionVar1

+ func (f ActionVar1[A1, VA]) SafeCall(a1 A1, args ...VA) (panicErr error)

+ func (f ActionVar1[A1, VA]) UnsafeCall(a1 A1, args ...VA)

type ActionVar10

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

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

type ActionVar11

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

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

type ActionVar12

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

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

type ActionVar13

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

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

type ActionVar14

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

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

type ActionVar15

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

+ func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...)

type ActionVar16

+ func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (panicErr error)

+ func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...)

type ActionVar2

+ func (f ActionVar2[A1, A2, VA]) SafeCall(a1 A1, a2 A2, args ...VA) (panicErr error)

+ func (f ActionVar2[A1, A2, VA]) UnsafeCall(a1 A1, a2 A2, args ...VA)

type ActionVar3

+ func (f ActionVar3[A1, A2, A3, VA]) SafeCall(a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)

+ func (f ActionVar3[A1, A2, A3, VA]) UnsafeCall(a1 A1, a2 A2, a3 A3, args ...VA)

type ActionVar4

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

+ func (f ActionVar4[A1, A2, A3, A4, VA]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA)

type ActionVar5

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

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

type ActionVar6

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

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

type ActionVar7

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

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

type ActionVar8

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

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

type ActionVar9

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

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

type Delegate0

+ func (d Delegate0[R]) SafeCall(interrupt Func2[R, error, bool]) (r R, panicErr error)

+ func (d Delegate0[R]) UnsafeCall(interrupt Func2[R, error, bool]) (r R)

type Delegate1

+ func (d Delegate1[A1, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1) (r R, panicErr error)

+ func (d Delegate1[A1, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1) (r R)

type Delegate10

+ func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate11

+ func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate12

+ func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate13

+ func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate14

+ func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate15

+ func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate16

+ func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate2

+ func (d Delegate2[A1, A2, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R, panicErr error)

+ func (d Delegate2[A1, A2, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R)

type Delegate3

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

+ func (d Delegate3[A1, A2, A3, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R)

type Delegate4

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

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

type Delegate5

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

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

type Delegate6

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

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

type Delegate7

+ func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate8

+ func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type Delegate9

+ func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegatePair0

+ func (d DelegatePair0[R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair0[R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2)

type DelegatePair1

+ func (d DelegatePair1[A1, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair1[A1, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2)

type DelegatePair10

+ func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) SafeCall(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 (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair11

+ func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) SafeCall(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 (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair12

+ func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) SafeCall(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 (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair13

+ func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) SafeCall(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 (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair14

+ func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) SafeCall(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 (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair15

+ func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) SafeCall(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 (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair16

+ func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) SafeCall(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 (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair2

+ func (d DelegatePair2[A1, A2, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair2[A1, A2, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2)

type DelegatePair3

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

type DelegatePair4

+ func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

type DelegatePair5

+ func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)

type DelegatePair6

+ func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) SafeCall(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 (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2)

type DelegatePair7

+ func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) SafeCall(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 (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair8

+ func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) SafeCall(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 (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePair9

+ func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) SafeCall(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 (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar0

+ func (d DelegatePairVar0[VA, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar0[VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2)

type DelegatePairVar1

+ func (d DelegatePairVar1[A1, VA, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar1[A1, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2)

type DelegatePairVar10

+ func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) SafeCall(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 (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar11

+ func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) SafeCall(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 (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar12

+ func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) SafeCall(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 (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar13

+ func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) SafeCall(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 (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar14

+ func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) SafeCall(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 (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar15

+ func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) SafeCall(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 (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar16

+ func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) SafeCall(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 (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar2

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

type DelegatePairVar3

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

type DelegatePairVar4

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

type DelegatePairVar5

+ func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) SafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2)

type DelegatePairVar6

+ func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) SafeCall(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 (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar7

+ func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) SafeCall(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 (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar8

+ func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) SafeCall(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 (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegatePairVar9

+ func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) SafeCall(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 (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) UnsafeCall(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)

type DelegateVar0

+ func (d DelegateVar0[VA, R]) SafeCall(interrupt Func2[R, error, bool], args ...VA) (r R, panicErr error)

+ func (d DelegateVar0[VA, R]) UnsafeCall(interrupt Func2[R, error, bool], args ...VA) (r R)

type DelegateVar1

+ func (d DelegateVar1[A1, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R, panicErr error)

+ func (d DelegateVar1[A1, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R)

type DelegateVar10

+ func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar11

+ func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar12

+ func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar13

+ func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar14

+ func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar15

+ func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar16

+ func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar2

+ func (d DelegateVar2[A1, A2, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R, panicErr error)

+ func (d DelegateVar2[A1, A2, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R)

type DelegateVar3

+ func (d DelegateVar3[A1, A2, A3, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

+ func (d DelegateVar3[A1, A2, A3, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R)

type DelegateVar4

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)

type DelegateVar5

+ func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R, panicErr error)

+ func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R)

type DelegateVar6

+ func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar7

+ func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar8

+ func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVar9

+ func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) SafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)

+ func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) UnsafeCall(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)

type DelegateVoid0

+ func (d DelegateVoid0) SafeCall(interrupt Func1[error, bool]) (panicErr error)

+ func (d DelegateVoid0) UnsafeCall(interrupt Func1[error, bool])

type DelegateVoid1

+ func (d DelegateVoid1[A1]) SafeCall(interrupt Func1[error, bool], a1 A1) (panicErr error)

+ func (d DelegateVoid1[A1]) UnsafeCall(interrupt Func1[error, bool], a1 A1)

type DelegateVoid10

+ func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid11

+ func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid12

+ func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid13

+ func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid14

+ func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid15

+ func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid16

+ func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid2

+ func (d DelegateVoid2[A1, A2]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)

+ func (d DelegateVoid2[A1, A2]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2)

type DelegateVoid3

+ func (d DelegateVoid3[A1, A2, A3]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)

+ func (d DelegateVoid3[A1, A2, A3]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3)

type DelegateVoid4

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

+ func (d DelegateVoid4[A1, A2, A3, A4]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4)

type DelegateVoid5

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

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

type DelegateVoid6

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

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

type DelegateVoid7

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

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

type DelegateVoid8

+ func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoid9

+ func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar0

+ func (d DelegateVoidVar0[VA]) SafeCall(interrupt Func1[error, bool], args ...VA) (panicErr error)

+ func (d DelegateVoidVar0[VA]) UnsafeCall(interrupt Func1[error, bool], args ...VA)

type DelegateVoidVar1

+ func (d DelegateVoidVar1[A1, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, args ...VA) (panicErr error)

+ func (d DelegateVoidVar1[A1, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, args ...VA)

type DelegateVoidVar10

+ func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar11

+ func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar12

+ func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar13

+ func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar14

+ func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar15

+ func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar16

+ func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type DelegateVoidVar2

+ func (d DelegateVoidVar2[A1, A2, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA) (panicErr error)

+ func (d DelegateVoidVar2[A1, A2, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA)

type DelegateVoidVar3

+ func (d DelegateVoidVar3[A1, A2, A3, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)

+ func (d DelegateVoidVar3[A1, A2, A3, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA)

type DelegateVoidVar4

+ func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (panicErr error)

+ func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA)

type DelegateVoidVar5

+ func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (panicErr error)

+ func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA)

type DelegateVoidVar6

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

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

type DelegateVoidVar7

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

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

type DelegateVoidVar8

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

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

type DelegateVoidVar9

+ func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) SafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)

+ func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) UnsafeCall(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)

type Func0

+ func (f Func0[R]) SafeCall() (r R, panicErr error)

+ func (f Func0[R]) UnsafeCall() (r R)

type Func1

+ func (f Func1[A1, R]) SafeCall(a1 A1) (r R, panicErr error)

+ func (f Func1[A1, R]) UnsafeCall(a1 A1) (r R)

type Func10

+ func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) SafeCall(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 (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10) (r R)

type Func11

+ func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) SafeCall(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 (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type Func12

+ func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) SafeCall(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 (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type Func13

+ func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) SafeCall(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 (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type Func14

+ func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) SafeCall(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 (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type Func15

+ func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) SafeCall(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 (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type Func16

+ func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) SafeCall(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 (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type Func2

+ func (f Func2[A1, A2, R]) SafeCall(a1 A1, a2 A2) (r R, panicErr error)

+ func (f Func2[A1, A2, R]) UnsafeCall(a1 A1, a2 A2) (r R)

type Func3

+ func (f Func3[A1, A2, A3, R]) SafeCall(a1 A1, a2 A2, a3 A3) (r R, panicErr error)

+ func (f Func3[A1, A2, A3, R]) UnsafeCall(a1 A1, a2 A2, a3 A3) (r R)

type Func4

+ func (f Func4[A1, A2, A3, A4, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

+ func (f Func4[A1, A2, A3, A4, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4) (r R)

type Func5

+ func (f Func5[A1, A2, A3, A4, A5, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R, panicErr error)

+ func (f Func5[A1, A2, A3, A4, A5, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R)

type Func6

+ func (f Func6[A1, A2, A3, A4, A5, A6, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r R, panicErr error)

+ func (f Func6[A1, A2, A3, A4, A5, A6, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r R)

type Func7

+ func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r R, panicErr error)

+ func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r R)

type Func8

+ func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r R, panicErr error)

+ func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r R)

type Func9

+ func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r R, panicErr error)

+ func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r R)

type FuncPair0

+ func (f FuncPair0[R1, R2]) SafeCall() (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair0[R1, R2]) UnsafeCall() (r1 R1, r2 R2)

type FuncPair1

+ func (f FuncPair1[A1, R1, R2]) SafeCall(a1 A1) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair1[A1, R1, R2]) UnsafeCall(a1 A1) (r1 R1, r2 R2)

type FuncPair10

+ func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) SafeCall(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 (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10) (r1 R1, r2 R2)

type FuncPair11

+ func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) SafeCall(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 (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPair12

+ func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) SafeCall(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 (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPair13

+ func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) SafeCall(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 (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPair14

+ func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) SafeCall(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 (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPair15

+ func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) SafeCall(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 (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPair16

+ func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) SafeCall(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 (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPair2

+ func (f FuncPair2[A1, A2, R1, R2]) SafeCall(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair2[A1, A2, R1, R2]) UnsafeCall(a1 A1, a2 A2) (r1 R1, r2 R2)

type FuncPair3

+ func (f FuncPair3[A1, A2, A3, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair3[A1, A2, A3, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

type FuncPair4

+ func (f FuncPair4[A1, A2, A3, A4, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair4[A1, A2, A3, A4, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

type FuncPair5

+ func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)

type FuncPair6

+ func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2)

type FuncPair7

+ func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r1 R1, r2 R2)

type FuncPair8

+ func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r1 R1, r2 R2)

type FuncPair9

+ func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) SafeCall(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 (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r1 R1, r2 R2)

type FuncPairVar0

+ func (f FuncPairVar0[VA, R1, R2]) SafeCall(args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar0[VA, R1, R2]) UnsafeCall(args ...VA) (r1 R1, r2 R2)

type FuncPairVar1

+ func (f FuncPairVar1[A1, VA, R1, R2]) SafeCall(a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar1[A1, VA, R1, R2]) UnsafeCall(a1 A1, args ...VA) (r1 R1, r2 R2)

type FuncPairVar10

+ func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) SafeCall(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 (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar11

+ func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) SafeCall(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 (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar12

+ func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) SafeCall(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 (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar13

+ func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) SafeCall(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 (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar14

+ func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) SafeCall(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 (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar15

+ func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) SafeCall(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 (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar16

+ func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) SafeCall(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 (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)

type FuncPairVar2

+ func (f FuncPairVar2[A1, A2, VA, R1, R2]) SafeCall(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar2[A1, A2, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

type FuncPairVar3

+ func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

type FuncPairVar4

+ func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

type FuncPairVar5

+ func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2)

type FuncPairVar6

+ func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2)

type FuncPairVar7

+ func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r1 R1, r2 R2)

type FuncPairVar8

+ func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r1 R1, r2 R2)

type FuncPairVar9

+ func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r1 R1, r2 R2)

type FuncVar0

+ func (f FuncVar0[VA, R]) SafeCall(args ...VA) (r R, panicErr error)

+ func (f FuncVar0[VA, R]) UnsafeCall(args ...VA) (r R)

type FuncVar1

+ func (f FuncVar1[A1, VA, R]) SafeCall(a1 A1, args ...VA) (r R, panicErr error)

+ func (f FuncVar1[A1, VA, R]) UnsafeCall(a1 A1, args ...VA) (r R)

type FuncVar10

+ func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) SafeCall(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 (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar11

+ func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) SafeCall(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 (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar12

+ func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) SafeCall(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 (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar13

+ func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) SafeCall(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 (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar14

+ func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) SafeCall(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 (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar15

+ func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) SafeCall(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 (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar16

+ func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) SafeCall(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 (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r R)

type FuncVar2

+ func (f FuncVar2[A1, A2, VA, R]) SafeCall(a1 A1, a2 A2, args ...VA) (r R, panicErr error)

+ func (f FuncVar2[A1, A2, VA, R]) UnsafeCall(a1 A1, a2 A2, args ...VA) (r R)

type FuncVar3

+ func (f FuncVar3[A1, A2, A3, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

+ func (f FuncVar3[A1, A2, A3, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, args ...VA) (r R)

type FuncVar4

+ func (f FuncVar4[A1, A2, A3, A4, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

+ func (f FuncVar4[A1, A2, A3, A4, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)

type FuncVar5

+ func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R, panicErr error)

+ func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R)

type FuncVar6

+ func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r R, panicErr error)

+ func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r R)

type FuncVar7

+ func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r R, panicErr error)

+ func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r R)

type FuncVar8

+ func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r R, panicErr error)

+ func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r R)

type FuncVar9

+ func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) SafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r R, panicErr error)

+ func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) UnsafeCall(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r R)

v0.3.88

Jan 14, 2025

v0.3.87

Jan 10, 2025

v0.3.86

Jan 9, 2025

v0.3.85

Jan 9, 2025

v0.3.84

Jan 9, 2025

v0.3.83

Jan 7, 2025

v0.3.82

Jan 7, 2025

v0.3.81

Jan 7, 2025

v0.3.80

Jan 7, 2025

v0.3.79

Dec 31, 2024

v0.3.78

Dec 31, 2024

v0.3.77

Dec 30, 2024

v0.3.76

Dec 30, 2024

v0.3.75

Dec 27, 2024

v0.3.74

Dec 26, 2024

v0.3.73

Dec 26, 2024

v0.3.72

Dec 26, 2024

v0.3.71

Dec 26, 2024

v0.3.70

Dec 25, 2024

v0.3.69

Dec 24, 2024

v0.3.68

Dec 24, 2024

v0.3.67

Dec 21, 2024

v0.3.66

Dec 21, 2024

Changes in this version

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

type Action0

+ func CastAction0[F ~func()](f F) Action0

type Action1

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

type Action10

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

type Action11

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

type Action12

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

type Action13

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

type Action14

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

type Action15

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

type Action16

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

type Action2

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

type Action3

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

type Action4

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

type Action5

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

type Action6

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

type Action7

+ func CastAction7[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]

type Action8

+ func CastAction8[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]

type Action9

+ func CastAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, ...](f F) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

type ActionVar0

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

type ActionVar1

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

type ActionVar10

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

type ActionVar11

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

type ActionVar12

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

type ActionVar13

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

type ActionVar14

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

type ActionVar15

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

type ActionVar16

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

type ActionVar2

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

type ActionVar3

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

type ActionVar4

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

type ActionVar5

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

type ActionVar6

+ func CastActionVar6[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]

type ActionVar7

+ func CastActionVar7[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]

type ActionVar8

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

type ActionVar9

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

+ type Delegate0 []Func0[R]

+ func CastDelegate0[R any, F ~func() R](fs ...F) Delegate0[R]

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

+ func (d Delegate0[R]) Combine(f ...Func0[R]) Delegate0[R]

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

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

+ func (d Delegate0[R]) ToFunc(interrupt Func2[R, error, bool]) Func0[R]

+ type Delegate1 []Func1[A1, R]

+ func CastDelegate1[A1, R any, F ~func(A1) R](fs ...F) Delegate1[A1, R]

+ func (d Delegate1[A1, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate1[A1, R]) Combine(f ...Func1[A1, R]) Delegate1[A1, R]

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

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

+ func (d Delegate1[A1, R]) ToFunc(interrupt Func2[R, error, bool]) Func1[A1, R]

+ type Delegate10 []...

+ func CastDelegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](fs ...F) Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

+ func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Combine(f ...Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

+ func (d Delegate10[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, ...) (r R)

+ func (d Delegate10[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, ...) (r R, panicErr error)

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

+ type Delegate11 []...

+ func CastDelegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](fs ...F) Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

+ func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Combine(f ...Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

+ func (d Delegate11[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, ...) (r R)

+ func (d Delegate11[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, ...) (r R, panicErr error)

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

+ type Delegate12 []...

+ func CastDelegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](fs ...F) Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

+ func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Combine(f ...Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

+ func (d Delegate12[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, ...) (r R)

+ func (d Delegate12[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, ...) (r R, panicErr error)

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

+ type Delegate13 []...

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

+ func (d Delegate13[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], ...) (r R, panicErr error)

+ func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Combine(f ...Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

+ func (d Delegate13[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, ...) (r R)

+ func (d Delegate13[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, ...) (r R, panicErr error)

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

+ type Delegate14 []...

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

+ func (d Delegate14[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], ...) (r R, panicErr error)

+ func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Combine(f ...Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

+ func (d Delegate14[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, ...) (r R)

+ func (d Delegate14[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, ...) (r R, panicErr error)

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

+ type Delegate15 []...

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

+ func (d Delegate15[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], ...) (r R, panicErr error)

+ func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Combine(...) ...

+ func (d Delegate15[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, ...) (r R)

+ func (d Delegate15[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, ...) (r R, panicErr error)

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

+ type Delegate16 []...

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

+ func (d Delegate16[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], ...) (r R, panicErr error)

+ func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Combine(...) ...

+ func (d Delegate16[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, ...) (r R)

+ func (d Delegate16[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, ...) (r R, panicErr error)

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

+ type Delegate2 []Func2[A1, A2, R]

+ func CastDelegate2[A1, A2, R any, F ~func(A1, A2) R](fs ...F) Delegate2[A1, A2, R]

+ func (d Delegate2[A1, A2, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

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

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

+ func (d Delegate2[A1, A2, R]) ToFunc(interrupt Func2[R, error, bool]) Func2[A1, A2, R]

+ type Delegate3 []Func3[A1, A2, A3, R]

+ func CastDelegate3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](fs ...F) Delegate3[A1, A2, A3, R]

+ func (d Delegate3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate3[A1, A2, A3, R]) Combine(f ...Func3[A1, A2, A3, R]) Delegate3[A1, A2, A3, R]

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

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

+ func (d Delegate3[A1, A2, A3, R]) ToFunc(interrupt Func2[R, error, bool]) Func3[A1, A2, A3, R]

+ type Delegate4 []Func4[A1, A2, A3, A4, R]

+ func CastDelegate4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](fs ...F) Delegate4[A1, A2, A3, A4, R]

+ func (d Delegate4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate4[A1, A2, A3, A4, R]) Combine(f ...Func4[A1, A2, A3, A4, R]) Delegate4[A1, A2, A3, A4, R]

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

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

+ func (d Delegate4[A1, A2, A3, A4, R]) ToFunc(interrupt Func2[R, error, bool]) Func4[A1, A2, A3, A4, R]

+ type Delegate5 []...

+ func CastDelegate5[A1, A2, A3, A4, A5, R any, F ~func(A1, A2, A3, A4, A5) R](fs ...F) Delegate5[A1, A2, A3, A4, A5, R]

+ func (d Delegate5[A1, A2, A3, A4, A5, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate5[A1, A2, A3, A4, A5, R]) Combine(f ...Func5[A1, A2, A3, A4, A5, R]) Delegate5[A1, A2, A3, A4, A5, R]

+ func (d Delegate5[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 (d Delegate5[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)

+ func (d Delegate5[A1, A2, A3, A4, A5, R]) ToFunc(interrupt Func2[R, error, bool]) Func5[A1, A2, A3, A4, A5, R]

+ type Delegate6 []...

+ func CastDelegate6[A1, A2, A3, A4, A5, A6, R any, F ~func(A1, A2, A3, A4, A5, A6) R](fs ...F) Delegate6[A1, A2, A3, A4, A5, A6, R]

+ func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) Combine(f ...Func6[A1, A2, A3, A4, A5, A6, R]) Delegate6[A1, A2, A3, A4, A5, A6, R]

+ func (d Delegate6[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 (d Delegate6[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)

+ func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) ToFunc(interrupt Func2[R, error, bool]) Func6[A1, A2, A3, A4, A5, A6, R]

+ type Delegate7 []...

+ func CastDelegate7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(A1, A2, A3, A4, A5, A6, A7) R](fs ...F) Delegate7[A1, A2, A3, A4, A5, A6, A7, R]

+ func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Combine(f ...Func7[A1, A2, A3, A4, A5, A6, A7, R]) Delegate7[A1, A2, A3, A4, A5, A6, A7, R]

+ func (d Delegate7[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, ...) (r R)

+ func (d Delegate7[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, ...) (r R, panicErr error)

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

+ type Delegate8 []...

+ func CastDelegate8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](fs ...F) Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]

+ func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Combine(f ...Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]

+ func (d Delegate8[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, ...) (r R)

+ func (d Delegate8[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, ...) (r R, panicErr error)

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

+ type Delegate9 []...

+ func CastDelegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](fs ...F) Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

+ func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Combine(f ...Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

+ func (d Delegate9[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, ...) (r R)

+ func (d Delegate9[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, ...) (r R, panicErr error)

+ func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToFunc(interrupt Func2[R, error, bool]) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

+ type DelegatePair0 []FuncPair0[R1, R2]

+ func CastDelegatePair0[R1, R2 any, F ~func() (R1, R2)](fs ...F) DelegatePair0[R1, R2]

+ func (d DelegatePair0[R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair0[R1, R2]) Combine(f ...FuncPair0[R1, R2]) DelegatePair0[R1, R2]

+ func (d DelegatePair0[R1, R2]) Exec(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2)

+ func (d DelegatePair0[R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair0[R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair0[R1, R2]

+ type DelegatePair1 []FuncPair1[A1, R1, R2]

+ func CastDelegatePair1[A1, R1, R2 any, F ~func(A1) (R1, R2)](fs ...F) DelegatePair1[A1, R1, R2]

+ func (d DelegatePair1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair1[A1, R1, R2]) Combine(f ...FuncPair1[A1, R1, R2]) DelegatePair1[A1, R1, R2]

+ func (d DelegatePair1[A1, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2)

+ func (d DelegatePair1[A1, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair1[A1, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair1[A1, R1, R2]

+ type DelegatePair10 []...

+ func CastDelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](fs ...F) DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Combine(f ...FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ func (d DelegatePair10[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair10[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ type DelegatePair11 []...

+ func CastDelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](fs ...F) DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ func (d DelegatePair11[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Combine(f ...FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ func (d DelegatePair11[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair11[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ type DelegatePair12 []...

+ func CastDelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](fs ...F) DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ func (d DelegatePair12[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Combine(f ...FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ func (d DelegatePair12[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair12[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ type DelegatePair13 []...

+ func CastDelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](fs ...F) DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

+ func (d DelegatePair13[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Combine(...) DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

+ func (d DelegatePair13[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair13[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

+ type DelegatePair14 []...

+ func CastDelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](fs ...F) ...

+ func (d DelegatePair14[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Combine(...) ...

+ func (d DelegatePair14[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair14[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePair15 []...

+ func CastDelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](fs ...F) ...

+ func (d DelegatePair15[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Combine(...) ...

+ func (d DelegatePair15[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair15[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePair16 []...

+ func CastDelegatePair16[...](fs ...F) ...

+ func (d DelegatePair16[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Combine(...) ...

+ func (d DelegatePair16[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair16[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePair2 []FuncPair2[A1, A2, R1, R2]

+ func CastDelegatePair2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](fs ...F) DelegatePair2[A1, A2, R1, R2]

+ func (d DelegatePair2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair2[A1, A2, R1, R2]) Combine(f ...FuncPair2[A1, A2, R1, R2]) DelegatePair2[A1, A2, R1, R2]

+ func (d DelegatePair2[A1, A2, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2)

+ func (d DelegatePair2[A1, A2, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair2[A1, A2, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair2[A1, A2, R1, R2]

+ type DelegatePair3 []FuncPair3[A1, A2, A3, R1, R2]

+ func CastDelegatePair3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](fs ...F) DelegatePair3[A1, A2, A3, R1, R2]

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) Combine(f ...FuncPair3[A1, A2, A3, R1, R2]) DelegatePair3[A1, A2, A3, R1, R2]

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair3[A1, A2, A3, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair3[A1, A2, A3, R1, R2]

+ type DelegatePair4 []FuncPair4[A1, A2, A3, A4, R1, R2]

+ func CastDelegatePair4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](fs ...F) DelegatePair4[A1, A2, A3, A4, R1, R2]

+ func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) Combine(f ...FuncPair4[A1, A2, A3, A4, R1, R2]) DelegatePair4[A1, A2, A3, A4, R1, R2]

+ func (d DelegatePair4[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 (d DelegatePair4[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)

+ func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair4[A1, A2, A3, A4, R1, R2]

+ type DelegatePair5 []...

+ func CastDelegatePair5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(A1, A2, A3, A4, A5) (R1, R2)](fs ...F) DelegatePair5[A1, A2, A3, A4, A5, R1, R2]

+ func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Combine(f ...FuncPair5[A1, A2, A3, A4, A5, R1, R2]) DelegatePair5[A1, A2, A3, A4, A5, R1, R2]

+ func (d DelegatePair5[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 (d DelegatePair5[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)

+ func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair5[A1, A2, A3, A4, A5, R1, R2]

+ type DelegatePair6 []...

+ func CastDelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(A1, A2, A3, A4, A5, A6) (R1, R2)](fs ...F) DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]

+ func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Combine(f ...FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]

+ func (d DelegatePair6[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 (d DelegatePair6[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)

+ func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]

+ type DelegatePair7 []...

+ func CastDelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](fs ...F) DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Combine(f ...FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ func (d DelegatePair7[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair7[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ type DelegatePair8 []...

+ func CastDelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](fs ...F) DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Combine(f ...FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ func (d DelegatePair8[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair8[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ type DelegatePair9 []...

+ func CastDelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](fs ...F) DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Combine(f ...FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ func (d DelegatePair9[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePair9[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ type DelegatePairVar0 []FuncPairVar0[VA, R1, R2]

+ func CastDelegatePairVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairVar0[VA, R1, R2]

+ func (d DelegatePairVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar0[VA, R1, R2]) Combine(f ...FuncPairVar0[VA, R1, R2]) DelegatePairVar0[VA, R1, R2]

+ func (d DelegatePairVar0[VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2)

+ func (d DelegatePairVar0[VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar0[VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar0[VA, R1, R2]

+ type DelegatePairVar1 []FuncPairVar1[A1, VA, R1, R2]

+ func CastDelegatePairVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](fs ...F) DelegatePairVar1[A1, VA, R1, R2]

+ func (d DelegatePairVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar1[A1, VA, R1, R2]) Combine(f ...FuncPairVar1[A1, VA, R1, R2]) DelegatePairVar1[A1, VA, R1, R2]

+ func (d DelegatePairVar1[A1, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2)

+ func (d DelegatePairVar1[A1, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar1[A1, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar1[A1, VA, R1, R2]

+ type DelegatePairVar10 []...

+ func CastDelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](fs ...F) DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ func (d DelegatePairVar10[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Combine(f ...FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ func (d DelegatePairVar10[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar10[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ type DelegatePairVar11 []...

+ func CastDelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](fs ...F) DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

+ func (d DelegatePairVar11[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Combine(f ...FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

+ func (d DelegatePairVar11[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar11[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

+ type DelegatePairVar12 []...

+ func CastDelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](fs ...F) ...

+ func (d DelegatePairVar12[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Combine(...) ...

+ func (d DelegatePairVar12[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar12[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

+ type DelegatePairVar13 []...

+ func CastDelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](fs ...F) ...

+ func (d DelegatePairVar13[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Combine(...) ...

+ func (d DelegatePairVar13[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar13[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePairVar14 []...

+ func CastDelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](fs ...F) ...

+ func (d DelegatePairVar14[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Combine(...) ...

+ func (d DelegatePairVar14[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar14[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePairVar15 []...

+ func CastDelegatePairVar15[...](fs ...F) ...

+ func (d DelegatePairVar15[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Combine(...) ...

+ func (d DelegatePairVar15[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar15[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePairVar16 []...

+ func CastDelegatePairVar16[...](fs ...F) ...

+ func (d DelegatePairVar16[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], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Combine(...) ...

+ func (d DelegatePairVar16[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar16[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

+ type DelegatePairVar2 []FuncPairVar2[A1, A2, VA, R1, R2]

+ func CastDelegatePairVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](fs ...F) DelegatePairVar2[A1, A2, VA, R1, R2]

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Combine(f ...FuncPairVar2[A1, A2, VA, R1, R2]) DelegatePairVar2[A1, A2, VA, R1, R2]

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar2[A1, A2, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar2[A1, A2, VA, R1, R2]

+ type DelegatePairVar3 []FuncPairVar3[A1, A2, A3, VA, R1, R2]

+ func CastDelegatePairVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](fs ...F) DelegatePairVar3[A1, A2, A3, VA, R1, R2]

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Combine(f ...FuncPairVar3[A1, A2, A3, VA, R1, R2]) DelegatePairVar3[A1, A2, A3, VA, R1, R2]

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar3[A1, A2, A3, VA, R1, R2]

+ type DelegatePairVar4 []FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]

+ func CastDelegatePairVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](fs ...F) DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Combine(f ...FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]

+ type DelegatePairVar5 []...

+ func CastDelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](fs ...F) DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Combine(f ...FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ func (d DelegatePairVar5[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar5[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ type DelegatePairVar6 []...

+ func CastDelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](fs ...F) DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Combine(f ...FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ func (d DelegatePairVar6[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar6[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ type DelegatePairVar7 []...

+ func CastDelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](fs ...F) DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Combine(f ...FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ func (d DelegatePairVar7[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar7[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ type DelegatePairVar8 []...

+ func CastDelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](fs ...F) DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Combine(f ...FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ func (d DelegatePairVar8[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar8[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ type DelegatePairVar9 []...

+ func CastDelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](fs ...F) DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

+ func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Combine(f ...FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

+ func (d DelegatePairVar9[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, ...) (r1 R1, r2 R2)

+ func (d DelegatePairVar9[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

+ type DelegateVar0 []FuncVar0[VA, R]

+ func CastDelegateVar0[VA, R any, F ~func(...VA) R](fs ...F) DelegateVar0[VA, R]

+ func (d DelegateVar0[VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar0[VA, R]) Combine(f ...FuncVar0[VA, R]) DelegateVar0[VA, R]

+ func (d DelegateVar0[VA, R]) Exec(interrupt Func2[R, error, bool], args ...VA) (r R)

+ func (d DelegateVar0[VA, R]) Invoke(interrupt Func2[R, error, bool], args ...VA) (r R, panicErr error)

+ func (d DelegateVar0[VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]

+ type DelegateVar1 []FuncVar1[A1, VA, R]

+ func CastDelegateVar1[A1, VA, R any, F ~func(A1, ...VA) R](fs ...F) DelegateVar1[A1, VA, R]

+ func (d DelegateVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar1[A1, VA, R]) Combine(f ...FuncVar1[A1, VA, R]) DelegateVar1[A1, VA, R]

+ func (d DelegateVar1[A1, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R)

+ func (d DelegateVar1[A1, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R, panicErr error)

+ func (d DelegateVar1[A1, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar1[A1, VA, R]

+ type DelegateVar10 []...

+ func CastDelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](fs ...F) DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

+ func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Combine(f ...FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

+ func (d DelegateVar10[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, ...) (r R)

+ func (d DelegateVar10[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, ...) (r R, panicErr error)

+ func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

+ type DelegateVar11 []...

+ func CastDelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](fs ...F) DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

+ func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Combine(f ...FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

+ func (d DelegateVar11[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, ...) (r R)

+ func (d DelegateVar11[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, ...) (r R, panicErr error)

+ func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

+ type DelegateVar12 []...

+ func CastDelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](fs ...F) DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

+ func (d DelegateVar12[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], ...) (r R, panicErr error)

+ func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Combine(f ...FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

+ func (d DelegateVar12[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, ...) (r R)

+ func (d DelegateVar12[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, ...) (r R, panicErr error)

+ func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

+ type DelegateVar13 []...

+ func CastDelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](fs ...F) DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

+ func (d DelegateVar13[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], ...) (r R, panicErr error)

+ func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Combine(f ...FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

+ func (d DelegateVar13[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, ...) (r R)

+ func (d DelegateVar13[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, ...) (r R, panicErr error)

+ func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

+ type DelegateVar14 []...

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

+ func (d DelegateVar14[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], ...) (r R, panicErr error)

+ func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Combine(...) ...

+ func (d DelegateVar14[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, ...) (r R)

+ func (d DelegateVar14[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, ...) (r R, panicErr error)

+ func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

+ type DelegateVar15 []...

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

+ func (d DelegateVar15[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], ...) (r R, panicErr error)

+ func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Combine(...) ...

+ func (d DelegateVar15[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, ...) (r R)

+ func (d DelegateVar15[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, ...) (r R, panicErr error)

+ func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...

+ type DelegateVar16 []...

+ func CastDelegateVar16[...](fs ...F) ...

+ func (d DelegateVar16[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], ...) (r R, panicErr error)

+ func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Combine(...) ...

+ func (d DelegateVar16[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, ...) (r R)

+ func (d DelegateVar16[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, ...) (r R, panicErr error)

+ func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...

+ type DelegateVar2 []FuncVar2[A1, A2, VA, R]

+ func CastDelegateVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateVar2[A1, A2, VA, R]

+ func (d DelegateVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar2[A1, A2, VA, R]) Combine(f ...FuncVar2[A1, A2, VA, R]) DelegateVar2[A1, A2, VA, R]

+ func (d DelegateVar2[A1, A2, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R)

+ func (d DelegateVar2[A1, A2, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R, panicErr error)

+ func (d DelegateVar2[A1, A2, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]

+ type DelegateVar3 []FuncVar3[A1, A2, A3, VA, R]

+ func CastDelegateVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateVar3[A1, A2, A3, VA, R]

+ func (d DelegateVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar3[A1, A2, A3, VA, R]) Combine(f ...FuncVar3[A1, A2, A3, VA, R]) DelegateVar3[A1, A2, A3, VA, R]

+ func (d DelegateVar3[A1, A2, A3, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R)

+ func (d DelegateVar3[A1, A2, A3, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

+ func (d DelegateVar3[A1, A2, A3, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]

+ type DelegateVar4 []FuncVar4[A1, A2, A3, A4, VA, R]

+ func CastDelegateVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](fs ...F) DelegateVar4[A1, A2, A3, A4, VA, R]

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Combine(f ...FuncVar4[A1, A2, A3, A4, VA, R]) DelegateVar4[A1, A2, A3, A4, VA, R]

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

+ func (d DelegateVar4[A1, A2, A3, A4, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]

+ type DelegateVar5 []...

+ func CastDelegateVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(A1, A2, A3, A4, A5, ...VA) R](fs ...F) DelegateVar5[A1, A2, A3, A4, A5, VA, R]

+ func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Combine(f ...FuncVar5[A1, A2, A3, A4, A5, VA, R]) DelegateVar5[A1, A2, A3, A4, A5, VA, R]

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

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

+ func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]

+ type DelegateVar6 []...

+ func CastDelegateVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(A1, A2, A3, A4, A5, A6, ...VA) R](fs ...F) DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]

+ func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Combine(f ...FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]

+ func (d DelegateVar6[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, ...) (r R)

+ func (d DelegateVar6[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, ...) (r R, panicErr error)

+ func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

+ type DelegateVar7 []...

+ func CastDelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](fs ...F) DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

+ func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Combine(f ...FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

+ func (d DelegateVar7[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, ...) (r R)

+ func (d DelegateVar7[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, ...) (r R, panicErr error)

+ func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

+ type DelegateVar8 []...

+ func CastDelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](fs ...F) DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

+ func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Combine(f ...FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

+ func (d DelegateVar8[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, ...) (r R)

+ func (d DelegateVar8[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, ...) (r R, panicErr error)

+ func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

+ type DelegateVar9 []...

+ func CastDelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](fs ...F) DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

+ func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Combine(f ...FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

+ func (d DelegateVar9[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, ...) (r R)

+ func (d DelegateVar9[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, ...) (r R, panicErr error)

+ func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

+ type DelegateVoid0 []Action0

+ func CastDelegateVoid0[F ~func()](fs ...F) DelegateVoid0

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

+ func (d DelegateVoid0) Combine(f ...Action0) DelegateVoid0

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

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

+ func (d DelegateVoid0) ToAction(interrupt Func1[error, bool]) Action0

+ type DelegateVoid1 []Action1[A1]

+ func CastDelegateVoid1[A1 any, F ~func(A1)](fs ...F) DelegateVoid1[A1]

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

+ func (d DelegateVoid1[A1]) Combine(f ...Action1[A1]) DelegateVoid1[A1]

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

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

+ func (d DelegateVoid1[A1]) ToAction(interrupt Func1[error, bool]) Action1[A1]

+ type DelegateVoid10 []...

+ func CastDelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, ...](fs ...F) DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

+ func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Combine(f ...Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

+ func (d DelegateVoid10[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, ...)

+ func (d DelegateVoid10[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, ...) (panicErr error)

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

+ type DelegateVoid11 []...

+ func CastDelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, ...](fs ...F) DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

+ func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Combine(f ...Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

+ func (d DelegateVoid11[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, ...)

+ func (d DelegateVoid11[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, ...) (panicErr error)

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

+ type DelegateVoid12 []...

+ func CastDelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, ...](fs ...F) DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

+ func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Combine(f ...Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

+ func (d DelegateVoid12[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, ...)

+ func (d DelegateVoid12[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, ...) (panicErr error)

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

+ type DelegateVoid13 []...

+ func CastDelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, ...](fs ...F) DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

+ func (d DelegateVoid13[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, ...) (panicErr error)

+ func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Combine(f ...Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

+ func (d DelegateVoid13[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, ...)

+ func (d DelegateVoid13[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, ...) (panicErr error)

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

+ type DelegateVoid14 []...

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

+ func (d DelegateVoid14[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, ...) (panicErr error)

+ func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Combine(f ...Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

+ func (d DelegateVoid14[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, ...)

+ func (d DelegateVoid14[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, ...) (panicErr error)

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

+ type DelegateVoid15 []...

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

+ func (d DelegateVoid15[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, ...) (panicErr error)

+ func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Combine(...) ...

+ func (d DelegateVoid15[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, ...)

+ func (d DelegateVoid15[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, ...) (panicErr error)

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

+ type DelegateVoid16 []...

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

+ func (d DelegateVoid16[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, ...) (panicErr error)

+ func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Combine(...) ...

+ func (d DelegateVoid16[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, ...)

+ func (d DelegateVoid16[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, ...) (panicErr error)

+ func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) ToAction(interrupt Func1[error, bool]) ...

+ type DelegateVoid2 []Action2[A1, A2]

+ func CastDelegateVoid2[A1, A2 any, F ~func(A1, A2)](fs ...F) DelegateVoid2[A1, A2]

+ func (d DelegateVoid2[A1, A2]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid2[A1, A2]) Combine(f ...Action2[A1, A2]) DelegateVoid2[A1, A2]

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

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

+ func (d DelegateVoid2[A1, A2]) ToAction(interrupt Func1[error, bool]) Action2[A1, A2]

+ type DelegateVoid3 []Action3[A1, A2, A3]

+ func CastDelegateVoid3[A1, A2, A3 any, F ~func(A1, A2, A3)](fs ...F) DelegateVoid3[A1, A2, A3]

+ func (d DelegateVoid3[A1, A2, A3]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid3[A1, A2, A3]) Combine(f ...Action3[A1, A2, A3]) DelegateVoid3[A1, A2, A3]

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

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

+ func (d DelegateVoid3[A1, A2, A3]) ToAction(interrupt Func1[error, bool]) Action3[A1, A2, A3]

+ type DelegateVoid4 []Action4[A1, A2, A3, A4]

+ func CastDelegateVoid4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](fs ...F) DelegateVoid4[A1, A2, A3, A4]

+ func (d DelegateVoid4[A1, A2, A3, A4]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid4[A1, A2, A3, A4]) Combine(f ...Action4[A1, A2, A3, A4]) DelegateVoid4[A1, A2, A3, A4]

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

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

+ func (d DelegateVoid4[A1, A2, A3, A4]) ToAction(interrupt Func1[error, bool]) Action4[A1, A2, A3, A4]

+ type DelegateVoid5 []...

+ func CastDelegateVoid5[A1, A2, A3, A4, A5 any, F ~func(A1, A2, A3, A4, A5)](fs ...F) DelegateVoid5[A1, A2, A3, A4, A5]

+ func (d DelegateVoid5[A1, A2, A3, A4, A5]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid5[A1, A2, A3, A4, A5]) Combine(f ...Action5[A1, A2, A3, A4, A5]) DelegateVoid5[A1, A2, A3, A4, A5]

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

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

+ func (d DelegateVoid5[A1, A2, A3, A4, A5]) ToAction(interrupt Func1[error, bool]) Action5[A1, A2, A3, A4, A5]

+ type DelegateVoid6 []...

+ func CastDelegateVoid6[A1, A2, A3, A4, A5, A6 any, F ~func(A1, A2, A3, A4, A5, A6)](fs ...F) DelegateVoid6[A1, A2, A3, A4, A5, A6]

+ func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Combine(f ...Action6[A1, A2, A3, A4, A5, A6]) DelegateVoid6[A1, A2, A3, A4, A5, A6]

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

+ func (d DelegateVoid6[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)

+ func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) ToAction(interrupt Func1[error, bool]) Action6[A1, A2, A3, A4, A5, A6]

+ type DelegateVoid7 []...

+ func CastDelegateVoid7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(A1, A2, A3, A4, A5, A6, A7)](fs ...F) DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]

+ func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Combine(f ...Action7[A1, A2, A3, A4, A5, A6, A7]) DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]

+ func (d DelegateVoid7[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 (d DelegateVoid7[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)

+ func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) ToAction(interrupt Func1[error, bool]) Action7[A1, A2, A3, A4, A5, A6, A7]

+ type DelegateVoid8 []...

+ func CastDelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(A1, A2, A3, A4, A5, A6, A7, A8)](fs ...F) DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]

+ func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Combine(f ...Action8[A1, A2, A3, A4, A5, A6, A7, A8]) DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]

+ func (d DelegateVoid8[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, ...)

+ func (d DelegateVoid8[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, ...) (panicErr error)

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

+ type DelegateVoid9 []...

+ func CastDelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, ...](fs ...F) DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

+ func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Combine(f ...Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

+ func (d DelegateVoid9[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, ...)

+ func (d DelegateVoid9[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, ...) (panicErr error)

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

+ type DelegateVoidVar0 []ActionVar0[VA]

+ func CastDelegateVoidVar0[VA any, F ~func(...VA)](fs ...F) DelegateVoidVar0[VA]

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

+ func (d DelegateVoidVar0[VA]) Combine(f ...ActionVar0[VA]) DelegateVoidVar0[VA]

+ func (d DelegateVoidVar0[VA]) Exec(interrupt Func1[error, bool], args ...VA)

+ func (d DelegateVoidVar0[VA]) Invoke(interrupt Func1[error, bool], args ...VA) (panicErr error)

+ func (d DelegateVoidVar0[VA]) ToAction(interrupt Func1[error, bool]) ActionVar0[VA]

+ type DelegateVoidVar1 []ActionVar1[A1, VA]

+ func CastDelegateVoidVar1[A1, VA, F ~func(A1, ...VA)](fs ...F) DelegateVoidVar1[A1, VA]

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

+ func (d DelegateVoidVar1[A1, VA]) Combine(f ...ActionVar1[A1, VA]) DelegateVoidVar1[A1, VA]

+ func (d DelegateVoidVar1[A1, VA]) Exec(interrupt Func1[error, bool], a1 A1, args ...VA)

+ func (d DelegateVoidVar1[A1, VA]) Invoke(interrupt Func1[error, bool], a1 A1, args ...VA) (panicErr error)

+ func (d DelegateVoidVar1[A1, VA]) ToAction(interrupt Func1[error, bool]) ActionVar1[A1, VA]

+ type DelegateVoidVar10 []...

+ func CastDelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, ...](fs ...F) DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

+ func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Combine(f ...ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

+ func (d DelegateVoidVar10[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, ...)

+ func (d DelegateVoidVar10[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, ...) (panicErr error)

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

+ type DelegateVoidVar11 []...

+ func CastDelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, ...](fs ...F) DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

+ func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Combine(f ...ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

+ func (d DelegateVoidVar11[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, ...)

+ func (d DelegateVoidVar11[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, ...) (panicErr error)

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

+ type DelegateVoidVar12 []...

+ func CastDelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, ...](fs ...F) DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

+ func (d DelegateVoidVar12[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, ...) (panicErr error)

+ func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Combine(f ...ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

+ func (d DelegateVoidVar12[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, ...)

+ func (d DelegateVoidVar12[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, ...) (panicErr error)

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

+ type DelegateVoidVar13 []...

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

+ func (d DelegateVoidVar13[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, ...) (panicErr error)

+ func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Combine(f ...ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

+ func (d DelegateVoidVar13[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, ...)

+ func (d DelegateVoidVar13[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, ...) (panicErr error)

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

+ type DelegateVoidVar14 []...

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

+ func (d DelegateVoidVar14[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, ...) (panicErr error)

+ func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Combine(...) ...

+ func (d DelegateVoidVar14[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, ...)

+ func (d DelegateVoidVar14[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, ...) (panicErr error)

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

+ type DelegateVoidVar15 []...

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

+ func (d DelegateVoidVar15[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, ...) (panicErr error)

+ func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Combine(...) ...

+ func (d DelegateVoidVar15[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, ...)

+ func (d DelegateVoidVar15[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, ...) (panicErr error)

+ func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) ToAction(interrupt Func1[error, bool]) ...

+ type DelegateVoidVar16 []...

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

+ func (d DelegateVoidVar16[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, ...) (panicErr error)

+ func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Combine(...) ...

+ func (d DelegateVoidVar16[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, ...)

+ func (d DelegateVoidVar16[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, ...) (panicErr error)

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

+ type DelegateVoidVar2 []ActionVar2[A1, A2, VA]

+ func CastDelegateVoidVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](fs ...F) DelegateVoidVar2[A1, A2, VA]

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

+ func (d DelegateVoidVar2[A1, A2, VA]) Combine(f ...ActionVar2[A1, A2, VA]) DelegateVoidVar2[A1, A2, VA]

+ func (d DelegateVoidVar2[A1, A2, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA)

+ func (d DelegateVoidVar2[A1, A2, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA) (panicErr error)

+ func (d DelegateVoidVar2[A1, A2, VA]) ToAction(interrupt Func1[error, bool]) ActionVar2[A1, A2, VA]

+ type DelegateVoidVar3 []ActionVar3[A1, A2, A3, VA]

+ func CastDelegateVoidVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](fs ...F) DelegateVoidVar3[A1, A2, A3, VA]

+ func (d DelegateVoidVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar3[A1, A2, A3, VA]) Combine(f ...ActionVar3[A1, A2, A3, VA]) DelegateVoidVar3[A1, A2, A3, VA]

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

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

+ func (d DelegateVoidVar3[A1, A2, A3, VA]) ToAction(interrupt Func1[error, bool]) ActionVar3[A1, A2, A3, VA]

+ type DelegateVoidVar4 []ActionVar4[A1, A2, A3, A4, VA]

+ func CastDelegateVoidVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](fs ...F) DelegateVoidVar4[A1, A2, A3, A4, VA]

+ func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Combine(f ...ActionVar4[A1, A2, A3, A4, VA]) DelegateVoidVar4[A1, A2, A3, A4, VA]

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

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

+ func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) ToAction(interrupt Func1[error, bool]) ActionVar4[A1, A2, A3, A4, VA]

+ type DelegateVoidVar5 []...

+ func CastDelegateVoidVar5[A1, A2, A3, A4, A5, VA any, F ~func(A1, A2, A3, A4, A5, ...VA)](fs ...F) DelegateVoidVar5[A1, A2, A3, A4, A5, VA]

+ func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Combine(f ...ActionVar5[A1, A2, A3, A4, A5, VA]) DelegateVoidVar5[A1, A2, A3, A4, A5, VA]

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

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

+ func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) ToAction(interrupt Func1[error, bool]) ActionVar5[A1, A2, A3, A4, A5, VA]

+ type DelegateVoidVar6 []...

+ func CastDelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(A1, A2, A3, A4, A5, A6, ...VA)](fs ...F) DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]

+ func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Combine(f ...ActionVar6[A1, A2, A3, A4, A5, A6, VA]) DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]

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

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

+ func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) ToAction(interrupt Func1[error, bool]) ActionVar6[A1, A2, A3, A4, A5, A6, VA]

+ type DelegateVoidVar7 []...

+ func CastDelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(A1, A2, A3, A4, A5, A6, A7, ...VA)](fs ...F) DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]

+ func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Combine(f ...ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]

+ func (d DelegateVoidVar7[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, ...)

+ func (d DelegateVoidVar7[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, ...) (panicErr error)

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

+ type DelegateVoidVar8 []...

+ func CastDelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, ...](fs ...F) DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

+ func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Combine(f ...ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

+ func (d DelegateVoidVar8[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, ...)

+ func (d DelegateVoidVar8[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, ...) (panicErr error)

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

+ type DelegateVoidVar9 []...

+ func CastDelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, ...](fs ...F) DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

+ func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Combine(f ...ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

+ func (d DelegateVoidVar9[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, ...)

+ func (d DelegateVoidVar9[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, ...) (panicErr error)

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

type Func0

+ func CastFunc0[R any, F ~func() R](f F) Func0[R]

type Func1

+ func CastFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]

type Func10

+ func CastFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

type Func11

+ func CastFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

type Func12

+ func CastFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

type Func13

+ func CastFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, ...](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

type Func14

+ func CastFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, ...](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

type Func15

+ func CastFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, ...](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

type Func16

+ func CastFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, ...](f F) ...

type Func2

+ func CastFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]

type Func3

+ func CastFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]

type Func4

+ func CastFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]

type Func5

+ func CastFunc5[A1, A2, A3, A4, A5, R any, F ~func(A1, A2, A3, A4, A5) R](f F) Func5[A1, A2, A3, A4, A5, R]

type Func6

+ func CastFunc6[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]

type Func7

+ func CastFunc7[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]

type Func8

+ func CastFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

type Func9

+ func CastFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

+ type FuncPair0 func() (R1, R2)

+ func CastFuncPair0[R1, R2 any, F ~func() (R1, R2)](f F) FuncPair0[R1, R2]

+ func (f FuncPair0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair0[R1, R2]) Exec() (r1 R1, r2 R2)

+ func (f FuncPair0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair0[R1, R2]) ToDelegate() DelegatePair0[R1, R2]

+ type FuncPair1 func(A1) (R1, R2)

+ func CastFuncPair1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) FuncPair1[A1, R1, R2]

+ func (f FuncPair1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)

+ func (f FuncPair1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair1[A1, R1, R2]) ToDelegate() DelegatePair1[A1, R1, R2]

+ type FuncPair10 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) (R1, R2)

+ func CastFuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](f F) FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ func (f FuncPair10[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair10[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 (f FuncPair10[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)

+ func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate() DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ type FuncPair11 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) (R1, R2)

+ func CastFuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](f F) FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ func (f FuncPair11[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair11[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, ...) (r1 R1, r2 R2)

+ func (f FuncPair11[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate() DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ type FuncPair12 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) (R1, R2)

+ func CastFuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](f F) FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ func (f FuncPair12[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair12[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, ...) (r1 R1, r2 R2)

+ func (f FuncPair12[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate() DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ type FuncPair13 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) (R1, R2)

+ func CastFuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](f F) FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

+ func (f FuncPair13[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair13[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, ...) (r1 R1, r2 R2)

+ func (f FuncPair13[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate() DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

+ type FuncPair14 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) (R1, R2)

+ func CastFuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](f F) ...

+ func (f FuncPair14[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair14[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, ...) (r1 R1, r2 R2)

+ func (f FuncPair14[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate() ...

+ type FuncPair15 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) (R1, R2)

+ func CastFuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](f F) ...

+ func (f FuncPair15[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair15[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, ...) (r1 R1, r2 R2)

+ func (f FuncPair15[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate() ...

+ type FuncPair16 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) (R1, R2)

+ func CastFuncPair16[...](f F) ...

+ func (f FuncPair16[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair16[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, ...) (r1 R1, r2 R2)

+ func (f FuncPair16[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate() ...

+ type FuncPair2 func(A1, A2) (R1, R2)

+ func CastFuncPair2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) FuncPair2[A1, A2, R1, R2]

+ func (f FuncPair2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)

+ func (f FuncPair2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair2[A1, A2, R1, R2]) ToDelegate() DelegatePair2[A1, A2, R1, R2]

+ type FuncPair3 func(A1, A2, A3) (R1, R2)

+ func CastFuncPair3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) FuncPair3[A1, A2, A3, R1, R2]

+ func (f FuncPair3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

+ func (f FuncPair3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair3[A1, A2, A3, R1, R2]) ToDelegate() DelegatePair3[A1, A2, A3, R1, R2]

+ type FuncPair4 func(A1, A2, A3, A4) (R1, R2)

+ func CastFuncPair4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](f F) FuncPair4[A1, A2, A3, A4, R1, R2]

+ func (f FuncPair4[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 (f FuncPair4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

+ func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair4[A1, A2, A3, A4, R1, R2]) ToDelegate() DelegatePair4[A1, A2, A3, A4, R1, R2]

+ type FuncPair5 func(A1, A2, A3, A4, A5) (R1, R2)

+ func CastFuncPair5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(A1, A2, A3, A4, A5) (R1, R2)](f F) FuncPair5[A1, A2, A3, A4, A5, R1, R2]

+ func (f FuncPair5[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 (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)

+ func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate() DelegatePair5[A1, A2, A3, A4, A5, R1, R2]

+ type FuncPair6 func(A1, A2, A3, A4, A5, A6) (R1, R2)

+ func CastFuncPair6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(A1, A2, A3, A4, A5, A6) (R1, R2)](f F) FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]

+ func (f FuncPair6[A1, A2, A3, A4, A5, A6, 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 (f FuncPair6[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 (f FuncPair6[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)

+ func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate() DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]

+ type FuncPair7 func(A1, A2, A3, A4, A5, A6, A7) (R1, R2)

+ func CastFuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](f F) FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ func (f FuncPair7[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair7[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 (f FuncPair7[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)

+ func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate() DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ type FuncPair8 func(A1, A2, A3, A4, A5, A6, A7, A8) (R1, R2)

+ func CastFuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](f F) FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ func (f FuncPair8[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair8[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 (f FuncPair8[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)

+ func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate() DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ type FuncPair9 func(A1, A2, A3, A4, A5, A6, A7, A8, A9) (R1, R2)

+ func CastFuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](f F) FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ func (f FuncPair9[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPair9[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 (f FuncPair9[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)

+ func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate() DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ type FuncPairVar0 func(...VA) (R1, R2)

+ func CastFuncPairVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) FuncPairVar0[VA, R1, R2]

+ func (f FuncPairVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar0[VA, R1, R2]) Exec(args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar0[VA, R1, R2]) Invoke(args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar0[VA, R1, R2]) ToDelegate() DelegatePairVar0[VA, R1, R2]

+ type FuncPairVar1 func(A1, ...VA) (R1, R2)

+ func CastFuncPairVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) FuncPairVar1[A1, VA, R1, R2]

+ func (f FuncPairVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar1[A1, VA, R1, R2]) Exec(a1 A1, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar1[A1, VA, R1, R2]) Invoke(a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar1[A1, VA, R1, R2]) ToDelegate() DelegatePairVar1[A1, VA, R1, R2]

+ type FuncPairVar10 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA) (R1, R2)

+ func CastFuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](f F) FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ func (f FuncPairVar10[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar10[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar10[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate() DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ type FuncPairVar11 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA) (R1, R2)

+ func CastFuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](f F) FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

+ func (f FuncPairVar11[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar11[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar11[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate() DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

+ type FuncPairVar12 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA) (R1, R2)

+ func CastFuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](f F) FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

+ func (f FuncPairVar12[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar12[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar12[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate() ...

+ type FuncPairVar13 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA) (R1, R2)

+ func CastFuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](f F) ...

+ func (f FuncPairVar13[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar13[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar13[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate() ...

+ type FuncPairVar14 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA) (R1, R2)

+ func CastFuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](f F) ...

+ func (f FuncPairVar14[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar14[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar14[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate() ...

+ type FuncPairVar15 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA) (R1, R2)

+ func CastFuncPairVar15[...](f F) ...

+ func (f FuncPairVar15[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar15[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar15[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate() ...

+ type FuncPairVar16 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA) (R1, R2)

+ func CastFuncPairVar16[...](f F) ...

+ func (f FuncPairVar16[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar16[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, ...) (r1 R1, r2 R2)

+ func (f FuncPairVar16[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate() ...

+ type FuncPairVar2 func(A1, A2, ...VA) (R1, R2)

+ func CastFuncPairVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) FuncPairVar2[A1, A2, VA, R1, R2]

+ func (f FuncPairVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar2[A1, A2, VA, R1, R2]) ToDelegate() DelegatePairVar2[A1, A2, VA, R1, R2]

+ type FuncPairVar3 func(A1, A2, A3, ...VA) (R1, R2)

+ func CastFuncPairVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](f F) FuncPairVar3[A1, A2, A3, VA, R1, R2]

+ func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) ToDelegate() DelegatePairVar3[A1, A2, A3, VA, R1, R2]

+ type FuncPairVar4 func(A1, A2, A3, A4, ...VA) (R1, R2)

+ func CastFuncPairVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](f F) FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]

+ func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate() DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]

+ type FuncPairVar5 func(A1, A2, A3, A4, A5, ...VA) (R1, R2)

+ func CastFuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](f F) FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, 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 (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate() DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ type FuncPairVar6 func(A1, A2, A3, A4, A5, A6, ...VA) (R1, R2)

+ func CastFuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](f F) FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ func (f FuncPairVar6[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate() DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ type FuncPairVar7 func(A1, A2, A3, A4, A5, A6, A7, ...VA) (R1, R2)

+ func CastFuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](f F) FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ func (f FuncPairVar7[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar7[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, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar7[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, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate() DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ type FuncPairVar8 func(A1, A2, A3, A4, A5, A6, A7, A8, ...VA) (R1, R2)

+ func CastFuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](f F) FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ func (f FuncPairVar8[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar8[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, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar8[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, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate() DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ type FuncPairVar9 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA) (R1, R2)

+ func CastFuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](f F) FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

+ func (f FuncPairVar9[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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar9[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, args ...VA) (r1 R1, r2 R2)

+ func (f FuncPairVar9[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, args ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate() DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

type FuncVar0

+ func CastFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]

type FuncVar1

+ func CastFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]

type FuncVar10

+ func CastFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

type FuncVar11

+ func CastFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

type FuncVar12

+ func CastFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

type FuncVar13

+ func CastFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

type FuncVar14

+ func CastFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, ...](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

type FuncVar15

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

type FuncVar16

+ func CastFuncVar16[...](f F) ...

type FuncVar2

+ func CastFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](f F) FuncVar2[A1, A2, VA, R]

type FuncVar3

+ func CastFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]

type FuncVar4

+ func CastFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](f F) FuncVar4[A1, A2, A3, A4, VA, R]

type FuncVar5

+ func CastFuncVar5[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]

type FuncVar6

+ func CastFuncVar6[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]

type FuncVar7

+ func CastFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

type FuncVar8

+ func CastFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

type FuncVar9

+ func CastFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

v0.3.65

Dec 13, 2024

v0.3.64

Dec 11, 2024

v0.3.63

Dec 11, 2024

v0.3.62

Dec 11, 2024

v0.3.61

Dec 3, 2024

Changes in this version

type SliceMap

+ func (m SliceMap[K, V]) Index(k K) int

type UnorderedSliceMap

+ func (m UnorderedSliceMap[K, V]) Index(k K) int

v0.3.60

Nov 26, 2024

v0.3.59

Nov 22, 2024

v0.3.58

Nov 21, 2024

v0.3.57

Nov 18, 2024

v0.3.56

Nov 16, 2024

v0.3.55

Nov 16, 2024

v0.3.54

Nov 15, 2024

v0.3.53

Nov 15, 2024

v0.3.52

Nov 14, 2024

v0.3.51

Nov 14, 2024

v0.3.50

Nov 14, 2024

v0.3.49

Nov 13, 2024

v0.3.48

Nov 13, 2024

v0.3.47

Nov 5, 2024

v0.3.46

Oct 20, 2024

v0.3.45

Oct 20, 2024

v0.3.44

Oct 20, 2024

v0.3.43

Oct 19, 2024

v0.3.42

Oct 19, 2024

v0.3.41

Oct 9, 2024

v0.3.40

Oct 9, 2024

v0.3.39

Sep 28, 2024

v0.3.38

Sep 28, 2024

v0.3.37

Sep 24, 2024

v0.3.36

Aug 30, 2024

v0.3.35

Aug 30, 2024

v0.3.34

Aug 30, 2024

v0.3.33

Aug 17, 2024

v0.3.32

Aug 11, 2024

Changes in this version

type Action0

+ func (f Action0) ToDelegate() DelegateAction0

type Action1

+ func (f Action1[A1]) ToDelegate() DelegateAction1[A1]

type Action10

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

type Action11

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

type Action12

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

type Action13

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

type Action14

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

type Action15

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

type Action16

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

type Action2

+ func (f Action2[A1, A2]) ToDelegate() DelegateAction2[A1, A2]

type Action3

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

type Action4

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

type Action5

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

type Action6

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

type Action7

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

type Action8

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

type Action9

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

type ActionVar0

+ func (f ActionVar0[VA]) ToDelegate() DelegateActionVar0[VA]

type ActionVar1

+ func (f ActionVar1[A1, VA]) ToDelegate() DelegateActionVar1[A1, VA]

type ActionVar10

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

type ActionVar11

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

type ActionVar12

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

type ActionVar13

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

type ActionVar14

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

type ActionVar15

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

type ActionVar16

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

type ActionVar2

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

type ActionVar3

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

type ActionVar4

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

type ActionVar5

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

type ActionVar6

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

type ActionVar7

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

type ActionVar8

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

type ActionVar9

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

type DelegateAction0

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

type DelegateAction1

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

type DelegateAction10

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

type DelegateAction11

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

type DelegateAction12

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

type DelegateAction13

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

type DelegateAction14

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

type DelegateAction15

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

type DelegateAction16

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

type DelegateAction2

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

type DelegateAction3

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

type DelegateAction4

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

type DelegateAction5

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

type DelegateAction6

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

type DelegateAction7

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

type DelegateAction8

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

type DelegateAction9

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

type DelegateActionVar0

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

type DelegateActionVar1

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

type DelegateActionVar10

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

type DelegateActionVar11

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

type DelegateActionVar12

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

type DelegateActionVar13

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

type DelegateActionVar14

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

type DelegateActionVar15

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

type DelegateActionVar16

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

type DelegateActionVar2

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

type DelegateActionVar3

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

type DelegateActionVar4

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

type DelegateActionVar5

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

type DelegateActionVar6

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

type DelegateActionVar7

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

type DelegateActionVar8

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

type DelegateActionVar9

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

type DelegateFunc0

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

type DelegateFunc1

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

type DelegateFunc10

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

type DelegateFunc11

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

type DelegateFunc12

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

type DelegateFunc13

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

type DelegateFunc14

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

type DelegateFunc15

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

type DelegateFunc16

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

type DelegateFunc2

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

type DelegateFunc3

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

type DelegateFunc4

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

type DelegateFunc5

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

type DelegateFunc6

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

type DelegateFunc7

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

type DelegateFunc8

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

type DelegateFunc9

+ func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToFunc(interrupt Func2[R, error, bool]) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

type DelegateFuncVar0

+ func (d DelegateFuncVar0[VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]

type DelegateFuncVar1

+ func (d DelegateFuncVar1[A1, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar1[A1, VA, R]

type DelegateFuncVar10

+ func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

type DelegateFuncVar11

+ func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

type DelegateFuncVar12

+ func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

type DelegateFuncVar13

+ func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

type DelegateFuncVar14

+ func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

type DelegateFuncVar15

+ func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...

type DelegateFuncVar16

+ func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...

type DelegateFuncVar2

+ func (d DelegateFuncVar2[A1, A2, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]

type DelegateFuncVar3

+ func (d DelegateFuncVar3[A1, A2, A3, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]

type DelegateFuncVar4

+ func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]

type DelegateFuncVar5

+ func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]

type DelegateFuncVar6

+ func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

type DelegateFuncVar7

+ func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

type DelegateFuncVar8

+ func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

type DelegateFuncVar9

+ func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

type DelegatePairFunc0

+ func (d DelegatePairFunc0[R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc0[R1, R2]

type DelegatePairFunc1

+ func (d DelegatePairFunc1[A1, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc1[A1, R1, R2]

type DelegatePairFunc10

+ func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

type DelegatePairFunc11

+ func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

type DelegatePairFunc12

+ func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

type DelegatePairFunc13

+ func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

type DelegatePairFunc14

+ func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFunc15

+ func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFunc16

+ func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFunc2

+ func (d DelegatePairFunc2[A1, A2, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc2[A1, A2, R1, R2]

type DelegatePairFunc3

+ func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc3[A1, A2, A3, R1, R2]

type DelegatePairFunc4

+ func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc4[A1, A2, A3, A4, R1, R2]

type DelegatePairFunc5

+ func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc5[A1, A2, A3, A4, A5, R1, R2]

type DelegatePairFunc6

+ func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

type DelegatePairFunc7

+ func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

type DelegatePairFunc8

+ func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

type DelegatePairFunc9

+ func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type DelegatePairFuncVar0

+ func (d DelegatePairFuncVar0[VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar0[VA, R1, R2]

type DelegatePairFuncVar1

+ func (d DelegatePairFuncVar1[A1, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar1[A1, VA, R1, R2]

type DelegatePairFuncVar10

+ func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

type DelegatePairFuncVar11

+ func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

type DelegatePairFuncVar12

+ func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

type DelegatePairFuncVar13

+ func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFuncVar14

+ func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFuncVar15

+ func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFuncVar16

+ func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFuncVar2

+ func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar2[A1, A2, VA, R1, R2]

type DelegatePairFuncVar3

+ func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar3[A1, A2, A3, VA, R1, R2]

type DelegatePairFuncVar4

+ func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

type DelegatePairFuncVar5

+ func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

type DelegatePairFuncVar6

+ func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

type DelegatePairFuncVar7

+ func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

type DelegatePairFuncVar8

+ func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

type DelegatePairFuncVar9

+ func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

type Func0

+ func (f Func0[R]) ToDelegate() DelegateFunc0[R]

type Func1

+ func (f Func1[A1, R]) ToDelegate() DelegateFunc1[A1, R]

type Func10

+ func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) ToDelegate() DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

type Func11

+ func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) ToDelegate() DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

type Func12

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

type Func13

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

type Func14

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

type Func15

+ func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) ToDelegate() ...

type Func16

+ func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) ToDelegate() ...

type Func2

+ func (f Func2[A1, A2, R]) ToDelegate() DelegateFunc2[A1, A2, R]

type Func3

+ func (f Func3[A1, A2, A3, R]) ToDelegate() DelegateFunc3[A1, A2, A3, R]

type Func4

+ func (f Func4[A1, A2, A3, A4, R]) ToDelegate() DelegateFunc4[A1, A2, A3, A4, R]

type Func5

+ func (f Func5[A1, A2, A3, A4, A5, R]) ToDelegate() DelegateFunc5[A1, A2, A3, A4, A5, R]

type Func6

+ func (f Func6[A1, A2, A3, A4, A5, A6, R]) ToDelegate() DelegateFunc6[A1, A2, A3, A4, A5, A6, R]

type Func7

+ func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) ToDelegate() DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]

type Func8

+ func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToDelegate() DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]

type Func9

+ func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToDelegate() DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

type FuncVar0

+ func (f FuncVar0[VA, R]) ToDelegate() DelegateFuncVar0[VA, R]

type FuncVar1

+ func (f FuncVar1[A1, VA, R]) ToDelegate() DelegateFuncVar1[A1, VA, R]

type FuncVar10

+ func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToDelegate() DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

type FuncVar11

+ func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToDelegate() DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

type FuncVar12

+ func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToDelegate() DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

type FuncVar13

+ func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToDelegate() ...

type FuncVar14

+ func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToDelegate() ...

type FuncVar15

+ func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToDelegate() ...

type FuncVar16

+ func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToDelegate() ...

type FuncVar2

+ func (f FuncVar2[A1, A2, VA, R]) ToDelegate() DelegateFuncVar2[A1, A2, VA, R]

type FuncVar3

+ func (f FuncVar3[A1, A2, A3, VA, R]) ToDelegate() DelegateFuncVar3[A1, A2, A3, VA, R]

type FuncVar4

+ func (f FuncVar4[A1, A2, A3, A4, VA, R]) ToDelegate() DelegateFuncVar4[A1, A2, A3, A4, VA, R]

type FuncVar5

+ func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) ToDelegate() DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]

type FuncVar6

+ func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToDelegate() DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

type FuncVar7

+ func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToDelegate() DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

type FuncVar8

+ func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToDelegate() DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

type FuncVar9

+ func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToDelegate() DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

type PairFunc0

+ func (f PairFunc0[R1, R2]) ToDelegate() DelegatePairFunc0[R1, R2]

type PairFunc1

+ func (f PairFunc1[A1, R1, R2]) ToDelegate() DelegatePairFunc1[A1, R1, R2]

type PairFunc10

+ func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate() DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

type PairFunc11

+ func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate() DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

type PairFunc12

+ func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate() DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

type PairFunc13

+ func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate() ...

type PairFunc14

+ func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate() ...

type PairFunc15

+ func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate() ...

type PairFunc16

+ func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate() ...

type PairFunc2

+ func (f PairFunc2[A1, A2, R1, R2]) ToDelegate() DelegatePairFunc2[A1, A2, R1, R2]

type PairFunc3

+ func (f PairFunc3[A1, A2, A3, R1, R2]) ToDelegate() DelegatePairFunc3[A1, A2, A3, R1, R2]

type PairFunc4

+ func (f PairFunc4[A1, A2, A3, A4, R1, R2]) ToDelegate() DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

type PairFunc5

+ func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate() DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

type PairFunc6

+ func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate() DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

type PairFunc7

+ func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate() DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

type PairFunc8

+ func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate() DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

type PairFunc9

+ func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate() DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type PairFuncVar0

+ func (f PairFuncVar0[VA, R1, R2]) ToDelegate() DelegatePairFuncVar0[VA, R1, R2]

type PairFuncVar1

+ func (f PairFuncVar1[A1, VA, R1, R2]) ToDelegate() DelegatePairFuncVar1[A1, VA, R1, R2]

type PairFuncVar10

+ func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate() DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

type PairFuncVar11

+ func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate() ...

type PairFuncVar12

+ func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate() ...

type PairFuncVar13

+ func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate() ...

type PairFuncVar14

+ func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate() ...

type PairFuncVar15

+ func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate() ...

type PairFuncVar16

+ func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate() ...

type PairFuncVar2

+ func (f PairFuncVar2[A1, A2, VA, R1, R2]) ToDelegate() DelegatePairFuncVar2[A1, A2, VA, R1, R2]

type PairFuncVar3

+ func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) ToDelegate() DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

type PairFuncVar4

+ func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate() DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

type PairFuncVar5

+ func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate() DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

type PairFuncVar6

+ func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate() DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

type PairFuncVar7

+ func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate() DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

type PairFuncVar8

+ func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate() DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

type PairFuncVar9

+ func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate() DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

v0.3.31

Aug 10, 2024

v0.3.22

Aug 10, 2024

v0.3.21

Aug 10, 2024

v0.3.20

Aug 9, 2024

v0.3.19

Aug 2, 2024

v0.3.18

Aug 2, 2024

v0.3.17

Aug 1, 2024

v0.3.16

Jul 9, 2024

v0.3.15

Jul 3, 2024

Changes in this version

type SliceMap

+ func (m SliceMap[K, V]) ReversedEach(fun Action2[K, V])

+ func (m SliceMap[K, V]) ReversedRange(fun Func2[K, V, bool])

type UnorderedSliceMap

+ func (m UnorderedSliceMap[K, V]) ReversedEach(fun Action2[K, V])

+ func (m UnorderedSliceMap[K, V]) ReversedRange(fun Func2[K, V, bool])

v0.3.14

Jul 2, 2024

v0.3.13

Jul 1, 2024

v0.3.12

Jun 30, 2024

Changes in this version

+ type Node struct

+ V T

+ func (n *Node[T]) Escape()

+ func (n *Node[T]) Escaped() bool

+ func (n *Node[T]) Next() *Node[T]

+ func (n *Node[T]) Prev() *Node[T]

+ func (n *Node[T]) Version() int64

v0.3.11

Jun 28, 2024

v0.3.10

Jun 24, 2024

v0.3.9

Jun 24, 2024

v0.3.8

Jun 24, 2024

v0.3.7

Jun 23, 2024

v0.3.6

Jun 23, 2024

v0.3.5

Jun 22, 2024

v0.3.4

Jun 22, 2024

v0.3.3

Jun 21, 2024

v0.3.2

Jun 20, 2024

Changes in this version

type SliceMap

+ func (m SliceMap[K, V]) Clone() SliceMap[K, V]

type UnorderedSliceMap

+ func (m UnorderedSliceMap[K, V]) Clone() UnorderedSliceMap[K, V]

v0.3.1

Jun 19, 2024

Changes in this version

type SliceMap

+ func (m SliceMap[K, V]) Keys() []K

+ func (m SliceMap[K, V]) Values() []V

type UnorderedSliceMap

+ func (m UnorderedSliceMap[K, V]) Keys() []K

+ func (m UnorderedSliceMap[K, V]) Values() []V

v0.3.0

Jun 17, 2024

v0.2.99

Jun 16, 2024

Changes in this version

type SliceMap

+ func (m SliceMap[K, V]) Len() int

type UnorderedSliceMap

+ func (m UnorderedSliceMap[K, V]) Len() int

v0.2.98

Jun 16, 2024

Changes in this version

type SliceMap

+ func (m SliceMap[K, V]) Each(fun Action2[K, V])

+ func (m SliceMap[K, V]) Range(fun Func2[K, V, bool])

+ func (m SliceMap[K, V]) ToUnorderedSliceMap() UnorderedSliceMap[K, V]

type UnorderedSliceMap

+ func (m UnorderedSliceMap[K, V]) Each(fun Action2[K, V])

+ func (m UnorderedSliceMap[K, V]) Range(fun Func2[K, V, bool])

v0.2.97

Jun 11, 2024

v0.2.96

Jun 10, 2024

Changes in this version

+ type Element struct

+ Value T

+ func (e *Element[T]) Escape()

+ func (e *Element[T]) Escaped() bool

+ func (e *Element[T]) Next() *Element[T]

+ func (e *Element[T]) Prev() *Element[T]

+ func (e *Element[T]) Version() int64

+ type List struct

+ func NewList[T any]() *List[T]

+ func (l *List[T]) Back() *Element[T]

+ func (l *List[T]) Front() *Element[T]

+ func (l *List[T]) InsertAfter(value T, at *Element[T]) *Element[T]

+ func (l *List[T]) InsertBefore(value T, at *Element[T]) *Element[T]

+ func (l *List[T]) Len() int

+ func (l *List[T]) MoveAfter(e, at *Element[T])

+ func (l *List[T]) MoveBefore(e, at *Element[T])

+ func (l *List[T]) MoveToBack(e *Element[T])

+ func (l *List[T]) MoveToFront(e *Element[T])

+ func (l *List[T]) PushBack(value T) *Element[T]

+ func (l *List[T]) PushBackList(other *List[T])

+ func (l *List[T]) PushFront(value T) *Element[T]

+ func (l *List[T]) PushFrontList(other *List[T])

+ func (l *List[T]) Remove(e *Element[T]) T

+ func (l *List[T]) ReversedTraversal(visitor func(e *Element[T]) bool)

+ func (l *List[T]) ReversedTraversalAt(visitor func(e *Element[T]) bool, at *Element[T])

+ func (l *List[T]) Traversal(visitor func(e *Element[T]) bool)

+ func (l *List[T]) TraversalAt(visitor func(e *Element[T]) bool, at *Element[T])

+ func (l *List[T]) Version() int64

v0.2.95

Jun 6, 2024

Changes in this version

+ type UnorderedKV struct

+ K K

+ V V

+ type UnorderedSliceMap []UnorderedKV[K, V]

+ func MakeUnorderedSliceMapFromGoMap[K comparable, V any](m map[K]V) UnorderedSliceMap[K, V]

+ func MakeUnorderedSliceMap[K comparable, V any](kvs ...UnorderedKV[K, V]) UnorderedSliceMap[K, V]

+ func NewUnorderedSliceMapFromGoMap[K comparable, V any](m map[K]V) *UnorderedSliceMap[K, V]

+ func NewUnorderedSliceMap[K comparable, V any](kvs ...UnorderedKV[K, V]) *UnorderedSliceMap[K, V]

+ func (m *UnorderedSliceMap[K, V]) Add(k K, v V)

+ func (m *UnorderedSliceMap[K, V]) Delete(k K) bool

+ func (m *UnorderedSliceMap[K, V]) TryAdd(k K, v V) bool

+ func (m UnorderedSliceMap[K, V]) Exist(k K) bool

+ func (m UnorderedSliceMap[K, V]) Get(k K) (V, bool)

+ func (m UnorderedSliceMap[K, V]) ToGoMap() map[K]V

+ func (m UnorderedSliceMap[K, V]) Value(k K) V

v0.2.94

Jun 6, 2024

v0.2.93

Jun 5, 2024

Changes in this version

+ type KV struct

+ K K

+ V V

+ type SliceMap []KV[K, V]

+ func MakeSliceMapFromGoMap[K comparable, V any](m map[K]V) SliceMap[K, V]

+ func MakeSliceMap[K comparable, V any](kvs ...KV[K, V]) SliceMap[K, V]

+ func NewSliceMapFromGoMap[K comparable, V any](m map[K]V) *SliceMap[K, V]

+ func NewSliceMap[K comparable, V any](kvs ...KV[K, V]) *SliceMap[K, V]

+ func (m *SliceMap[K, V]) Add(k K, v V)

+ func (m *SliceMap[K, V]) Delete(k K) bool

+ func (m *SliceMap[K, V]) TryAdd(k K, v V) bool

+ func (m SliceMap[K, V]) Exist(k K) bool

+ func (m SliceMap[K, V]) Get(k K) (V, bool)

+ func (m SliceMap[K, V]) ToGoMap() map[K]V

+ func (m SliceMap[K, V]) Value(k K) V

v0.2.92

Jun 4, 2024

v0.2.91

Jun 1, 2024

v0.2.90

May 30, 2024

v0.2.89

May 30, 2024

v0.2.88

May 29, 2024

v0.2.87

May 28, 2024

v0.2.86

May 28, 2024

v0.2.85

May 28, 2024

v0.2.84

May 28, 2024

Changes in this version

+ func FuncError(err, panicErr error) error

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

+ type Action0 func()

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

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

+ func (f Action0) CastDelegate() DelegateAction0

+ func (f Action0) Exec()

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

+ type Action1 func(A1)

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

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

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

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

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

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

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

+ 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, ...) (panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

+ type Action2 func(A1, A2)

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

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

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

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

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

+ type Action3 func(A1, A2, A3)

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

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

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

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

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

+ type Action4 func(A1, A2, A3, A4)

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

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

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

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

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

+ type Action5 func(A1, A2, A3, A4, A5)

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

+ 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 (f Action5[A1, A2, A3, A4, A5]) CastDelegate() DelegateAction5[A1, A2, A3, A4, A5]

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

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

+ type Action6 func(A1, A2, A3, A4, A5, A6)

+ 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 (f Action6[A1, A2, A3, A4, A5, A6]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (panicErr error)

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

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

+ 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 func(A1, A2, A3, A4, A5, A6, A7)

+ 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 (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, ...) (panicErr error)

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

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8)

+ 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 (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, ...) (panicErr error)

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

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9)

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

+ 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, ...) (panicErr error)

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

+ 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 (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 func(...VA)

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

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

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

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

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

+ type ActionVar1 func(A1, ...VA)

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

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

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

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

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

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

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

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

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

+ type ActionVar2 func(A1, A2, ...VA)

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

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

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

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

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

+ type ActionVar3 func(A1, A2, A3, ...VA)

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

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

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

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

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

+ type ActionVar4 func(A1, A2, A3, A4, ...VA)

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

+ 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 (f ActionVar4[A1, A2, A3, A4, VA]) CastDelegate() DelegateActionVar4[A1, A2, A3, A4, VA]

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

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

+ type ActionVar5 func(A1, A2, A3, A4, A5, ...VA)

+ 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 (f ActionVar5[A1, A2, A3, A4, A5, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (panicErr error)

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

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

+ 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 func(A1, A2, A3, A4, A5, A6, ...VA)

+ 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 (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, ...) (panicErr error)

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

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, ...VA)

+ 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 (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, ...) (panicErr error)

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

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, ...VA)

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

+ 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, ...) (panicErr error)

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

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA)

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

+ 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, ...) (panicErr error)

+ 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 (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 (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 []Action0

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

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

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

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

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

+ type DelegateAction1 []Action1[A1]

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

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

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

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

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

+ type DelegateAction10 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction11 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction12 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction13 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction14 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction15 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction16 []...

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction2 []Action2[A1, A2]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type DelegateAction5 []...

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

+ func (d DelegateAction5[A1, A2, A3, A4, A5]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

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

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

+ 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 []...

+ 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 (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

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

+ 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 (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 []...

+ 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 (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

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

+ 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 (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 []...

+ 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 (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateAction9 []...

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

+ func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar0 []ActionVar0[VA]

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

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

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

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

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

+ type DelegateActionVar1 []ActionVar1[A1, VA]

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

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

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

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

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

+ type DelegateActionVar10 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar11 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar12 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar13 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar14 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar15 []...

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

+ 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, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar16 []...

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

+ 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, ...) (panicErr error)

+ 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]) ...

+ 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, ...)

+ 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, ...) (panicErr error)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ 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 []...

+ 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 (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

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

+ 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 (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 []...

+ 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 (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

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

+ 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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar7 []...

+ 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 (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar8 []...

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

+ func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateActionVar9 []...

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

+ 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, ...) (panicErr error)

+ 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 (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, ...)

+ 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, ...) (panicErr error)

+ type DelegateFunc0 []Func0[R]

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

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

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

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

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

+ type DelegateFunc1 []Func1[A1, R]

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

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

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

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

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

+ type DelegateFunc10 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc11 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc12 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc13 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc14 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc15 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc16 []...

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

+ 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], ...) (r R, panicErr error)

+ 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]) ...

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

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

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

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

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

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

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

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

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

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

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

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

+ 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 []Func4[A1, A2, A3, A4, R]

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

+ func (d DelegateFunc4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

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

+ 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 (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 []...

+ 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 (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

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

+ 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 (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 []...

+ 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 (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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 (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 []...

+ 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 (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc8 []...

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

+ func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFunc9 []...

+ func MakeDelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](fs ...F) DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

+ func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar0 []FuncVar0[VA, R]

+ func MakeDelegateFuncVar0[VA, R any, F ~func(...VA) R](fs ...F) DelegateFuncVar0[VA, R]

+ func (d DelegateFuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateFuncVar0[VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]

+ func (d DelegateFuncVar0[VA, R]) Exec(interrupt Func2[R, error, bool], va ...VA) (r R)

+ func (d DelegateFuncVar0[VA, R]) Invoke(interrupt Func2[R, error, bool], va ...VA) (r R, panicErr error)

+ type DelegateFuncVar1 []FuncVar1[A1, VA, R]

+ func MakeDelegateFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](fs ...F) DelegateFuncVar1[A1, VA, R]

+ func (d DelegateFuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateFuncVar1[A1, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar1[A1, VA, R]

+ func (d DelegateFuncVar1[A1, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, va ...VA) (r R)

+ func (d DelegateFuncVar1[A1, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, va ...VA) (r R, panicErr error)

+ type DelegateFuncVar10 []...

+ func MakeDelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](fs ...F) DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar11 []...

+ func MakeDelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](fs ...F) DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar12 []...

+ func MakeDelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](fs ...F) DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar13 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar14 []...

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

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar15 []...

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

+ 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], ...) (r R, panicErr error)

+ 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]) ...

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar16 []...

+ func MakeDelegateFuncVar16[...](fs ...F) ...

+ 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], ...) (r R, panicErr error)

+ 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]) ...

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar2 []FuncVar2[A1, A2, VA, R]

+ func MakeDelegateFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateFuncVar2[A1, A2, VA, R]

+ func (d DelegateFuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateFuncVar2[A1, A2, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]

+ func (d DelegateFuncVar2[A1, A2, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, va ...VA) (r R)

+ 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 []FuncVar3[A1, A2, A3, VA, R]

+ func MakeDelegateFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateFuncVar3[A1, A2, A3, VA, R]

+ func (d DelegateFuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateFuncVar3[A1, A2, A3, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]

+ 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 (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 []FuncVar4[A1, A2, A3, A4, VA, R]

+ 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 (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]

+ 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 (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 []...

+ 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 (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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 (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 []...

+ 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 (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar7 []...

+ func MakeDelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](fs ...F) DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

+ func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar8 []...

+ func MakeDelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](fs ...F) DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

+ func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegateFuncVar9 []...

+ func MakeDelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](fs ...F) DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

+ 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], ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type DelegatePairFunc0 []PairFunc0[R1, R2]

+ func MakeDelegatePairFunc0[R1, R2 any, F ~func() (R1, R2)](fs ...F) DelegatePairFunc0[R1, R2]

+ func (d DelegatePairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFunc0[R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc0[R1, R2]

+ func (d DelegatePairFunc0[R1, R2]) Exec(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2)

+ func (d DelegatePairFunc0[R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc1 []PairFunc1[A1, R1, R2]

+ func MakeDelegatePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](fs ...F) DelegatePairFunc1[A1, R1, R2]

+ func (d DelegatePairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFunc1[A1, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc1[A1, R1, R2]

+ func (d DelegatePairFunc1[A1, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2)

+ func (d DelegatePairFunc1[A1, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc10 []...

+ func MakeDelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](fs ...F) DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc11 []...

+ func MakeDelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](fs ...F) DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc12 []...

+ func MakeDelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](fs ...F) DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc13 []...

+ func MakeDelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc14 []...

+ func MakeDelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc15 []...

+ func MakeDelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc16 []...

+ func MakeDelegatePairFunc16[...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc2 []PairFunc2[A1, A2, R1, R2]

+ func MakeDelegatePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](fs ...F) DelegatePairFunc2[A1, A2, R1, R2]

+ func (d DelegatePairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFunc2[A1, A2, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc2[A1, A2, R1, R2]

+ func (d DelegatePairFunc2[A1, A2, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2)

+ 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 []PairFunc3[A1, A2, A3, R1, R2]

+ func MakeDelegatePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](fs ...F) DelegatePairFunc3[A1, A2, A3, R1, R2]

+ func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc3[A1, A2, A3, R1, R2]

+ 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 (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 []PairFunc4[A1, A2, A3, A4, R1, R2]

+ 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 (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc4[A1, A2, A3, A4, R1, R2]

+ 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 (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 []...

+ 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 (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 []...

+ 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 (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 []...

+ func MakeDelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](fs ...F) DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc8 []...

+ func MakeDelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](fs ...F) DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFunc9 []...

+ func MakeDelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](fs ...F) DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar0 []PairFuncVar0[VA, R1, R2]

+ func MakeDelegatePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairFuncVar0[VA, R1, R2]

+ func (d DelegatePairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFuncVar0[VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar0[VA, R1, R2]

+ func (d DelegatePairFuncVar0[VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], va ...VA) (r1 R1, r2 R2)

+ func (d DelegatePairFuncVar0[VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], va ...VA) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar1 []PairFuncVar1[A1, VA, R1, R2]

+ func MakeDelegatePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar1[A1, VA, R1, R2]

+ func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFuncVar1[A1, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar1[A1, VA, R1, R2]

+ func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, va ...VA) (r1 R1, r2 R2)

+ 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 []...

+ func MakeDelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar11 []...

+ func MakeDelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar12 []...

+ func MakeDelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar13 []...

+ func MakeDelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar14 []...

+ func MakeDelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar15 []...

+ func MakeDelegatePairFuncVar15[...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar16 []...

+ func MakeDelegatePairFuncVar16[...](fs ...F) ...

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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]) ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar2 []PairFuncVar2[A1, A2, VA, R1, R2]

+ func MakeDelegatePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar2[A1, A2, VA, R1, R2]

+ func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar2[A1, A2, VA, R1, R2]

+ 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 (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 []PairFuncVar3[A1, A2, A3, VA, R1, R2]

+ 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 (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar3[A1, A2, A3, VA, R1, R2]

+ 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 (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 []PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

+ 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 (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 []...

+ func MakeDelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar6 []...

+ func MakeDelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar7 []...

+ func MakeDelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar8 []...

+ func MakeDelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type DelegatePairFuncVar9 []...

+ func MakeDelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

+ 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], ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type Func0 func() R

+ func MakeFunc0[R any, F ~func() R](f F) Func0[R]

+ func (f Func0[R]) Call(autoRecover bool, reportError chan error) (r R, panicErr error)

+ func (f Func0[R]) CastDelegate() DelegateFunc0[R]

+ func (f Func0[R]) Exec() (r R)

+ func (f Func0[R]) Invoke() (r R, panicErr error)

+ type Func1 func(A1) R

+ func MakeFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]

+ func (f Func1[A1, R]) Call(autoRecover bool, reportError chan error, a1 A1) (r R, panicErr error)

+ func (f Func1[A1, R]) CastDelegate() DelegateFunc1[A1, R]

+ func (f Func1[A1, R]) Exec(a1 A1) (r R)

+ func (f Func1[A1, R]) Invoke(a1 A1) (r R, panicErr error)

+ type Func10 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) R

+ func MakeFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) R

+ func MakeFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type Func12 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) R

+ func MakeFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type Func13 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) R

+ func MakeFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, ...](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type Func14 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) R

+ func MakeFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, ...](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type Func15 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) R

+ func MakeFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, ...](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

+ 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, ...) (r R, panicErr error)

+ func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) CastDelegate() ...

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type Func16 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) R

+ func MakeFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, ...](f F) ...

+ 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, ...) (r R, panicErr error)

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

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type Func2 func(A1, A2) R

+ func MakeFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]

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

+ func (f Func2[A1, A2, R]) CastDelegate() DelegateFunc2[A1, A2, R]

+ func (f Func2[A1, A2, R]) Exec(a1 A1, a2 A2) (r R)

+ func (f Func2[A1, A2, R]) Invoke(a1 A1, a2 A2) (r R, panicErr error)

+ type Func3 func(A1, A2, A3) R

+ func MakeFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]

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

+ func (f Func3[A1, A2, A3, R]) CastDelegate() DelegateFunc3[A1, A2, A3, R]

+ func (f Func3[A1, A2, A3, R]) Exec(a1 A1, a2 A2, a3 A3) (r R)

+ func (f Func3[A1, A2, A3, R]) Invoke(a1 A1, a2 A2, a3 A3) (r R, panicErr error)

+ type Func4 func(A1, A2, A3, A4) R

+ func MakeFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]

+ 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 (f Func4[A1, A2, A3, A4, R]) CastDelegate() DelegateFunc4[A1, A2, A3, A4, R]

+ func (f Func4[A1, A2, A3, A4, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r R)

+ func (f Func4[A1, A2, A3, A4, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

+ type Func5 func(A1, A2, A3, A4, A5) R

+ 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 (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 (f Func5[A1, A2, A3, A4, A5, R]) CastDelegate() DelegateFunc5[A1, A2, A3, A4, A5, R]

+ func (f Func5[A1, A2, A3, A4, A5, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R)

+ 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 func(A1, A2, A3, A4, A5, A6) R

+ 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 (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, ...) (r R, panicErr error)

+ func (f Func6[A1, A2, A3, A4, A5, A6, R]) CastDelegate() DelegateFunc6[A1, A2, A3, A4, A5, A6, R]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7) R

+ 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 (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, ...) (r R, panicErr error)

+ func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) CastDelegate() DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8) R

+ func MakeFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

+ 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, ...) (r R, panicErr error)

+ func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) CastDelegate() DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9) R

+ func MakeFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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 (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 func(...VA) R

+ func MakeFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]

+ func (f FuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, va ...VA) (r R, panicErr error)

+ func (f FuncVar0[VA, R]) CastDelegate() DelegateFuncVar0[VA, R]

+ func (f FuncVar0[VA, R]) Exec(va ...VA) (r R)

+ func (f FuncVar0[VA, R]) Invoke(va ...VA) (r R, panicErr error)

+ type FuncVar1 func(A1, ...VA) R

+ func MakeFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]

+ func (f FuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, va ...VA) (r R, panicErr error)

+ func (f FuncVar1[A1, VA, R]) CastDelegate() DelegateFuncVar1[A1, VA, R]

+ func (f FuncVar1[A1, VA, R]) Exec(a1 A1, va ...VA) (r R)

+ func (f FuncVar1[A1, VA, R]) Invoke(a1 A1, va ...VA) (r R, panicErr error)

+ type FuncVar10 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA) R

+ func MakeFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar11 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA) R

+ func MakeFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar12 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA) R

+ func MakeFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar13 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA) R

+ func MakeFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

+ 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, ...) (r R, panicErr error)

+ func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) CastDelegate() ...

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar14 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA) R

+ func MakeFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, ...](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

+ 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, ...) (r R, panicErr error)

+ func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) CastDelegate() ...

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar15 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA) R

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

+ 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, ...) (r R, panicErr error)

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

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar16 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA) R

+ func MakeFuncVar16[...](f F) ...

+ 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, ...) (r R, panicErr error)

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

+ 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, ...) (r R)

+ 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, ...) (r R, panicErr error)

+ type FuncVar2 func(A1, A2, ...VA) R

+ func MakeFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](f F) FuncVar2[A1, A2, VA, R]

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

+ func (f FuncVar2[A1, A2, VA, R]) CastDelegate() DelegateFuncVar2[A1, A2, VA, R]

+ func (f FuncVar2[A1, A2, VA, R]) Exec(a1 A1, a2 A2, va ...VA) (r R)

+ func (f FuncVar2[A1, A2, VA, R]) Invoke(a1 A1, a2 A2, va ...VA) (r R, panicErr error)

+ type FuncVar3 func(A1, A2, A3, ...VA) R

+ func MakeFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]

+ 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 (f FuncVar3[A1, A2, A3, VA, R]) CastDelegate() DelegateFuncVar3[A1, A2, A3, VA, R]

+ func (f FuncVar3[A1, A2, A3, VA, R]) Exec(a1 A1, a2 A2, a3 A3, va ...VA) (r R)

+ func (f FuncVar3[A1, A2, A3, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, va ...VA) (r R, panicErr error)

+ type FuncVar4 func(A1, A2, A3, A4, ...VA) R

+ 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 (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 (f FuncVar4[A1, A2, A3, A4, VA, R]) CastDelegate() DelegateFuncVar4[A1, A2, A3, A4, VA, R]

+ func (f FuncVar4[A1, A2, A3, A4, VA, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, va ...VA) (r R)

+ 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 func(A1, A2, A3, A4, A5, ...VA) R

+ 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 (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, ...) (r R, panicErr error)

+ func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) CastDelegate() DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, ...VA) R

+ 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 (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, ...) (r R, panicErr error)

+ func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) CastDelegate() DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, ...VA) R

+ func MakeFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

+ 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, ...) (r R, panicErr error)

+ func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) CastDelegate() DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, ...VA) R

+ func MakeFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA) R

+ func MakeFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

+ 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, ...) (r R, panicErr error)

+ 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 (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 (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 func() (R1, R2)

+ func MakePairFunc0[R1, R2 any, F ~func() (R1, R2)](f F) PairFunc0[R1, R2]

+ func (f PairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc0[R1, R2]) CastDelegate() DelegatePairFunc0[R1, R2]

+ func (f PairFunc0[R1, R2]) Exec() (r1 R1, r2 R2)

+ func (f PairFunc0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)

+ type PairFunc1 func(A1) (R1, R2)

+ func MakePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) PairFunc1[A1, R1, R2]

+ func (f PairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc1[A1, R1, R2]) CastDelegate() DelegatePairFunc1[A1, R1, R2]

+ func (f PairFunc1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)

+ func (f PairFunc1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)

+ type PairFunc10 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) (R1, R2)

+ func MakePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](f F) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) (R1, R2)

+ func MakePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](f F) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFunc12 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) (R1, R2)

+ func MakePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](f F) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFunc13 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) (R1, R2)

+ func MakePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](f F) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFunc14 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) (R1, R2)

+ func MakePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFunc15 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) (R1, R2)

+ func MakePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFunc16 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) (R1, R2)

+ func MakePairFunc16[...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFunc2 func(A1, A2) (R1, R2)

+ func MakePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) PairFunc2[A1, A2, R1, R2]

+ func (f PairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc2[A1, A2, R1, R2]) CastDelegate() DelegatePairFunc2[A1, A2, R1, R2]

+ func (f PairFunc2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)

+ func (f PairFunc2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

+ type PairFunc3 func(A1, A2, A3) (R1, R2)

+ func MakePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) PairFunc3[A1, A2, A3, R1, R2]

+ 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 (f PairFunc3[A1, A2, A3, R1, R2]) CastDelegate() DelegatePairFunc3[A1, A2, A3, R1, R2]

+ func (f PairFunc3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

+ func (f PairFunc3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

+ type PairFunc4 func(A1, A2, A3, A4) (R1, R2)

+ 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 (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 (f PairFunc4[A1, A2, A3, A4, R1, R2]) CastDelegate() DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

+ func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

+ 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 func(A1, A2, A3, A4, A5) (R1, R2)

+ 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 (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 (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) CastDelegate() DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

+ 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 (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 func(A1, A2, A3, A4, A5, A6) (R1, R2)

+ 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 (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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) CastDelegate() DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7) (R1, R2)

+ func MakePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](f F) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) CastDelegate() DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8) (R1, R2)

+ func MakePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](f F) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9) (R1, R2)

+ func MakePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](f F) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 func(...VA) (R1, R2)

+ func MakePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) PairFuncVar0[VA, R1, R2]

+ func (f PairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, va ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar0[VA, R1, R2]) CastDelegate() DelegatePairFuncVar0[VA, R1, R2]

+ func (f PairFuncVar0[VA, R1, R2]) Exec(va ...VA) (r1 R1, r2 R2)

+ func (f PairFuncVar0[VA, R1, R2]) Invoke(va ...VA) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar1 func(A1, ...VA) (R1, R2)

+ func MakePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) PairFuncVar1[A1, VA, R1, R2]

+ func (f PairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, va ...VA) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar1[A1, VA, R1, R2]) CastDelegate() DelegatePairFuncVar1[A1, VA, R1, R2]

+ func (f PairFuncVar1[A1, VA, R1, R2]) Exec(a1 A1, va ...VA) (r1 R1, r2 R2)

+ func (f PairFuncVar1[A1, VA, R1, R2]) Invoke(a1 A1, va ...VA) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar10 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA) (R1, R2)

+ func MakePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](f F) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar11 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA) (R1, R2)

+ func MakePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](f F) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar12 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA) (R1, R2)

+ func MakePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](f F) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar13 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA) (R1, R2)

+ func MakePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar14 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA) (R1, R2)

+ func MakePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar15 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA) (R1, R2)

+ func MakePairFuncVar15[...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar16 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA) (R1, R2)

+ func MakePairFuncVar16[...](f F) ...

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) CastDelegate() ...

+ 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, ...) (r1 R1, r2 R2)

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar2 func(A1, A2, ...VA) (R1, R2)

+ func MakePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) PairFuncVar2[A1, A2, VA, R1, R2]

+ 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 (f PairFuncVar2[A1, A2, VA, R1, R2]) CastDelegate() DelegatePairFuncVar2[A1, A2, VA, R1, R2]

+ func (f PairFuncVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2)

+ func (f PairFuncVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, va ...VA) (r1 R1, r2 R2, panicErr error)

+ type PairFuncVar3 func(A1, A2, A3, ...VA) (R1, R2)

+ 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 (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 (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) CastDelegate() DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

+ func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, va ...VA) (r1 R1, r2 R2)

+ 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 func(A1, A2, A3, A4, ...VA) (R1, R2)

+ 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 (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 (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) CastDelegate() DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

+ 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 (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 func(A1, A2, A3, A4, A5, ...VA) (R1, R2)

+ func MakePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](f F) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) CastDelegate() DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, ...VA) (R1, R2)

+ func MakePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](f F) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) CastDelegate() DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

+ 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 (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 func(A1, A2, A3, A4, A5, A6, A7, ...VA) (R1, R2)

+ func MakePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](f F) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, ...VA) (R1, R2)

+ func MakePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](f F) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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 func(A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA) (R1, R2)

+ func MakePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](f F) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

+ 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, ...) (r1 R1, r2 R2, panicErr error)

+ 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 (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 (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)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL