generic

package

Go to main page

Versions in this module

v0

v0.2.83

May 27, 2024

v0.2.82

May 26, 2024

v0.2.81

May 26, 2024

v0.2.80

May 26, 2024

v0.2.79

May 26, 2024

v0.2.78

May 26, 2024

v0.2.77

May 26, 2024

v0.2.76

May 26, 2024

v0.2.75

May 25, 2024

v0.2.74

May 22, 2024

v0.2.73

May 21, 2024

v0.2.72

May 21, 2024

v0.2.71

May 16, 2024

v0.2.70

May 15, 2024

v0.2.69

May 15, 2024

v0.2.68

May 15, 2024

v0.2.67

May 15, 2024

v0.2.66

May 15, 2024

v0.2.65

May 15, 2024

v0.2.64

May 15, 2024

v0.2.63

May 15, 2024

v0.2.62

May 15, 2024

v0.2.61

May 14, 2024

v0.2.60

Apr 29, 2024

v0.2.59

Apr 29, 2024

v0.2.58

Apr 29, 2024

v0.2.57

Apr 19, 2024

v0.2.56

Apr 19, 2024

v0.2.55

Apr 16, 2024

v0.2.54

Apr 16, 2024

v0.2.53

Apr 16, 2024

v0.2.52

Apr 15, 2024

Changes in this version

type Action0

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

+ func (f Action0) CastDelegate() DelegateAction0

type Action1

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

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

type Action10

+ 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]) CastDelegate() DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

type Action11

+ 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]) CastDelegate() DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

type Action12

+ 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]) CastDelegate() DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

type Action13

+ 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]) CastDelegate() DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

type Action14

+ 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]) CastDelegate() DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

type Action15

+ 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]) CastDelegate() ...

type Action16

+ 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]) CastDelegate() ...

type Action2

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

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

type Action3

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

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

type Action4

+ 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]) CastDelegate() DelegateAction4[A1, A2, A3, A4]

type Action5

+ 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]) CastDelegate() DelegateAction5[A1, A2, A3, A4, A5]

type Action6

+ 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]) CastDelegate() DelegateAction6[A1, A2, A3, A4, A5, A6]

type Action7

+ 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]) CastDelegate() DelegateAction7[A1, A2, A3, A4, A5, A6, A7]

type Action8

+ 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]) CastDelegate() DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]

type Action9

+ 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]) CastDelegate() DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

type ActionVar0

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

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

type ActionVar1

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

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

type ActionVar10

+ 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]) CastDelegate() DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

type ActionVar11

+ 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]) CastDelegate() DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

type ActionVar12

+ 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]) CastDelegate() DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

type ActionVar13

+ 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]) CastDelegate() ...

type ActionVar14

+ 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]) CastDelegate() ...

type ActionVar15

+ 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]) CastDelegate() ...

type ActionVar16

+ 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]) CastDelegate() ...

type ActionVar2

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

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

type ActionVar3

+ 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]) CastDelegate() DelegateActionVar3[A1, A2, A3, VA]

type ActionVar4

+ 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]) CastDelegate() DelegateActionVar4[A1, A2, A3, A4, VA]

type ActionVar5

+ 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]) CastDelegate() DelegateActionVar5[A1, A2, A3, A4, A5, VA]

type ActionVar6

+ 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]) CastDelegate() DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]

type ActionVar7

+ 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]) CastDelegate() DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

type ActionVar8

+ 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]) CastDelegate() DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

type ActionVar9

+ 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]) CastDelegate() DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

type DelegateAction0

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

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

type DelegateAction1

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

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

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]) CastAction(interrupt Func1[error, bool]) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

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]) CastAction(interrupt Func1[error, bool]) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

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]) CastAction(interrupt Func1[error, bool]) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

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]) CastAction(interrupt Func1[error, bool]) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

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]) CastAction(interrupt Func1[error, bool]) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

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]) CastAction(interrupt Func1[error, bool]) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

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]) CastAction(interrupt Func1[error, bool]) ...

type DelegateAction2

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

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

type DelegateAction3

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

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

type DelegateAction4

+ 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]) CastAction(interrupt Func1[error, bool]) Action4[A1, A2, A3, A4]

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]) CastAction(interrupt Func1[error, bool]) Action5[A1, A2, A3, A4, A5]

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]) CastAction(interrupt Func1[error, bool]) Action6[A1, A2, A3, A4, A5, A6]

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]) CastAction(interrupt Func1[error, bool]) Action7[A1, A2, A3, A4, A5, A6, A7]

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]) CastAction(interrupt Func1[error, bool]) Action8[A1, A2, A3, A4, A5, A6, A7, A8]

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]) CastAction(interrupt Func1[error, bool]) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

type DelegateActionVar0

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

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

type DelegateActionVar1

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

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

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]) CastAction(interrupt Func1[error, bool]) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

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]) CastAction(interrupt Func1[error, bool]) ...

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]) CastAction(interrupt Func1[error, bool]) ...

type DelegateActionVar2

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

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

type DelegateActionVar3

+ 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]) CastAction(interrupt Func1[error, bool]) ActionVar3[A1, A2, A3, VA]

type DelegateActionVar4

+ 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]) CastAction(interrupt Func1[error, bool]) ActionVar4[A1, A2, A3, A4, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar5[A1, A2, A3, A4, A5, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar6[A1, A2, A3, A4, A5, A6, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

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]) CastAction(interrupt Func1[error, bool]) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

type DelegateFunc0

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

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

type DelegateFunc1

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

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

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]) CastFunc(interrupt Func2[R, error, bool]) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

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]) CastFunc(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 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]) CastFunc(interrupt Func2[R, error, bool]) ...

type DelegateFunc2

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

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

type DelegateFunc3

+ 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]) CastFunc(interrupt Func2[R, error, bool]) Func3[A1, A2, A3, R]

type DelegateFunc4

+ 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]) CastFunc(interrupt Func2[R, error, bool]) Func4[A1, A2, A3, A4, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func5[A1, A2, A3, A4, A5, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func6[A1, A2, A3, A4, A5, A6, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func7[A1, A2, A3, A4, A5, A6, A7, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

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]) CastFunc(interrupt Func2[R, error, bool]) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

type DelegateFuncVar0

+ func MakeDelegateFuncVar0[VA, R any, F ~func(...VA) R](fs ...F) DelegateFuncVar0[VA, R]

+ func (d DelegateFuncVar0[VA, R]) CastFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]

type DelegateFuncVar1

+ func MakeDelegateFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](fs ...F) DelegateFuncVar1[A1, VA, R]

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

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

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]) CastFunc(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 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]) CastFunc(interrupt Func2[R, error, bool]) ...

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]) CastFunc(interrupt Func2[R, error, bool]) ...

type DelegateFuncVar2

+ 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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]

type DelegateFuncVar3

+ 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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]

type DelegateFuncVar4

+ 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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

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]) CastFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

type DelegatePairFunc0

+ func MakeDelegatePairFunc0[R1, R2 any, F ~func() (R1, R2)](fs ...F) DelegatePairFunc0[R1, R2]

+ func (d DelegatePairFunc0[R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc0[R1, R2]

type DelegatePairFunc1

+ func MakeDelegatePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](fs ...F) DelegatePairFunc1[A1, R1, R2]

+ func (d DelegatePairFunc1[A1, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc1[A1, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

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]) CastFunc(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 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFunc2

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc2[A1, A2, R1, R2]

type DelegatePairFunc3

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc3[A1, A2, A3, R1, R2]

type DelegatePairFunc4

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc4[A1, A2, A3, A4, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc5[A1, A2, A3, A4, A5, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type DelegatePairFuncVar0

+ func MakeDelegatePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairFuncVar0[VA, R1, R2]

+ func (d DelegatePairFuncVar0[VA, R1, R2]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar0[VA, R1, R2]

type DelegatePairFuncVar1

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar1[A1, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

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]) CastFunc(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 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) ...

type DelegatePairFuncVar2

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar2[A1, A2, VA, R1, R2]

type DelegatePairFuncVar3

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar3[A1, A2, A3, VA, R1, R2]

type DelegatePairFuncVar4

+ 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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

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]) CastFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

type Func0

+ func MakeFunc0[R any, F ~func() R](f F) Func0[R]

+ func (f Func0[R]) CastDelegate() DelegateFunc0[R]

type Func1

+ func MakeFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]

+ func (f Func1[A1, R]) CastDelegate() DelegateFunc1[A1, R]

type Func10

+ 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]) CastDelegate() DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

type Func11

+ 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]) CastDelegate() DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

type Func12

+ 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]) CastDelegate() DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

type Func13

+ 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]) CastDelegate() DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

type Func14

+ 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]) CastDelegate() DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

type Func15

+ 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]) CastDelegate() ...

type Func16

+ 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]) CastDelegate() ...

type Func2

+ func MakeFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]

+ func (f Func2[A1, A2, R]) CastDelegate() DelegateFunc2[A1, A2, R]

type Func3

+ 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]) CastDelegate() DelegateFunc3[A1, A2, A3, R]

type Func4

+ 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]) CastDelegate() DelegateFunc4[A1, A2, A3, A4, R]

type Func5

+ 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]) CastDelegate() DelegateFunc5[A1, A2, A3, A4, A5, R]

type Func6

+ 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]) CastDelegate() DelegateFunc6[A1, A2, A3, A4, A5, A6, R]

type Func7

+ 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]) CastDelegate() DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]

type Func8

+ 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]) CastDelegate() DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]

type Func9

+ 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]) CastDelegate() DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

type FuncVar0

+ func MakeFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]

+ func (f FuncVar0[VA, R]) CastDelegate() DelegateFuncVar0[VA, R]

type FuncVar1

+ func MakeFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]

+ func (f FuncVar1[A1, VA, R]) CastDelegate() DelegateFuncVar1[A1, VA, R]

type FuncVar10

+ 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]) CastDelegate() DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

type FuncVar11

+ 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]) CastDelegate() DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

type FuncVar12

+ 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]) CastDelegate() DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

type FuncVar13

+ 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]) CastDelegate() ...

type FuncVar14

+ 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]) CastDelegate() ...

type FuncVar15

+ 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]) CastDelegate() ...

type FuncVar16

+ 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]) CastDelegate() ...

type FuncVar2

+ 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]) CastDelegate() DelegateFuncVar2[A1, A2, VA, R]

type FuncVar3

+ 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]) CastDelegate() DelegateFuncVar3[A1, A2, A3, VA, R]

type FuncVar4

+ 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]) CastDelegate() DelegateFuncVar4[A1, A2, A3, A4, VA, R]

type FuncVar5

+ 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]) CastDelegate() DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]

type FuncVar6

+ 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]) CastDelegate() DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

type FuncVar7

+ 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]) CastDelegate() DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

type FuncVar8

+ 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]) CastDelegate() DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

type FuncVar9

+ 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]) CastDelegate() DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

type PairFunc0

+ func MakePairFunc0[R1, R2 any, F ~func() (R1, R2)](f F) PairFunc0[R1, R2]

+ func (f PairFunc0[R1, R2]) CastDelegate() DelegatePairFunc0[R1, R2]

type PairFunc1

+ func MakePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) PairFunc1[A1, R1, R2]

+ func (f PairFunc1[A1, R1, R2]) CastDelegate() DelegatePairFunc1[A1, R1, R2]

type PairFunc10

+ 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]) CastDelegate() DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

type PairFunc11

+ 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]) CastDelegate() DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

type PairFunc12

+ 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]) CastDelegate() DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

type PairFunc13

+ 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]) CastDelegate() ...

type PairFunc14

+ 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]) CastDelegate() ...

type PairFunc15

+ 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]) CastDelegate() ...

type PairFunc16

+ 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]) CastDelegate() ...

type PairFunc2

+ 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]) CastDelegate() DelegatePairFunc2[A1, A2, R1, R2]

type PairFunc3

+ 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]) CastDelegate() DelegatePairFunc3[A1, A2, A3, R1, R2]

type PairFunc4

+ 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]) CastDelegate() DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

type PairFunc5

+ 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]) CastDelegate() DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

type PairFunc6

+ 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]) CastDelegate() DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

type PairFunc7

+ 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]) CastDelegate() DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

type PairFunc8

+ 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]) CastDelegate() DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

type PairFunc9

+ 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]) CastDelegate() DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type PairFuncVar0

+ func MakePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) PairFuncVar0[VA, R1, R2]

+ func (f PairFuncVar0[VA, R1, R2]) CastDelegate() DelegatePairFuncVar0[VA, R1, R2]

type PairFuncVar1

+ 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]) CastDelegate() DelegatePairFuncVar1[A1, VA, R1, R2]

type PairFuncVar10

+ 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]) CastDelegate() DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

type PairFuncVar11

+ 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]) CastDelegate() ...

type PairFuncVar12

+ 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]) CastDelegate() ...

type PairFuncVar13

+ 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]) CastDelegate() ...

type PairFuncVar14

+ 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]) CastDelegate() ...

type PairFuncVar15

+ 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]) CastDelegate() ...

type PairFuncVar16

+ 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]) CastDelegate() ...

type PairFuncVar2

+ 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]) CastDelegate() DelegatePairFuncVar2[A1, A2, VA, R1, R2]

type PairFuncVar3

+ 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]) CastDelegate() DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

type PairFuncVar4

+ 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]) CastDelegate() DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

type PairFuncVar5

+ 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]) CastDelegate() DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

type PairFuncVar6

+ 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]) CastDelegate() DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

type PairFuncVar7

+ 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]) CastDelegate() DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

type PairFuncVar8

+ 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]) CastDelegate() DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

type PairFuncVar9

+ 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]) CastDelegate() DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

v0.2.51

Apr 14, 2024

v0.2.50

Apr 13, 2024

v0.2.49

Mar 30, 2024

v0.2.48

Mar 16, 2024

v0.2.47

Mar 16, 2024

v0.2.46

Mar 14, 2024

v0.2.45

Mar 3, 2024

v0.2.44

Mar 2, 2024

v0.2.43

Feb 21, 2024

v0.2.42

Feb 20, 2024

v0.2.41

Feb 20, 2024

v0.2.40

Feb 20, 2024

v0.2.39

Feb 20, 2024

v0.2.38

Feb 20, 2024

v0.2.37

Feb 19, 2024

v0.2.36

Feb 19, 2024

v0.2.35

Feb 19, 2024

v0.2.34

Feb 19, 2024

v0.2.33

Feb 19, 2024

v0.2.32

Feb 1, 2024

v0.2.31

Jan 28, 2024

v0.2.30

Jan 28, 2024

v0.2.29

Jan 27, 2024

v0.2.28

Jan 26, 2024

v0.2.27

Jan 26, 2024

v0.2.26

Jan 25, 2024

v0.2.25

Jan 24, 2024

v0.2.24

Jan 24, 2024

v0.2.23

Jan 23, 2024

v0.2.22

Jan 22, 2024

v0.2.21

Jan 22, 2024

v0.2.20

Jan 13, 2024

v0.2.19

Jan 13, 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 CastAction0[F ~func()](f F) Action0

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

+ func (f Action0) Exec()

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

+ type Action1 func(A1)

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

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastAction16[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]) 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 CastAction2[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]) Exec(a1 A1, a2 A2)

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

+ type Action3 func(A1, A2, A3)

+ func CastAction3[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]) 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 CastAction4[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]) 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 CastAction5[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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastAction9[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]) 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 CastActionVar0[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]) Exec(va ...VA)

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

+ type ActionVar1 func(A1, ...VA)

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

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastActionVar15[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]) 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 CastActionVar16[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]) 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 CastActionVar2[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]) 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 CastActionVar3[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]) 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 CastActionVar4[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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastActionVar8[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]) 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 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]

+ 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]) 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 CastDelegateAction0[F ~func()](fs ...F) DelegateAction0

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

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

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

+ type DelegateAction1 []Action1[A1]

+ func CastDelegateAction1[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]) Exec(interrupt Func1[error, bool], a1 A1)

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

+ type DelegateAction10 []...

+ func CastDelegateAction10[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]) 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 CastDelegateAction11[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]) 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 CastDelegateAction12[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]) 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 CastDelegateAction13[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]) 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 CastDelegateAction14[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]) 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 CastDelegateAction15[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]) 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 CastDelegateAction16[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]) 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 CastDelegateAction2[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]) 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 CastDelegateAction3[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]) 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 CastDelegateAction4[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]) 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 CastDelegateAction5[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]) 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 CastDelegateAction6[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]) 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 CastDelegateAction7[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]) 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 CastDelegateAction8[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]) 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 CastDelegateAction9[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]) 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 CastDelegateActionVar0[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]) 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 CastDelegateActionVar1[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]) 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 CastDelegateActionVar10[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]) 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 CastDelegateActionVar11[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]) 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 CastDelegateActionVar12[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]) 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 CastDelegateActionVar13[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]) 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 CastDelegateActionVar14[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]) 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 CastDelegateActionVar15[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]) 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 CastDelegateActionVar16[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]) 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 CastDelegateActionVar2[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]) 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 CastDelegateActionVar3[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]) 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 CastDelegateActionVar4[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]) 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 CastDelegateActionVar5[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]) 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 CastDelegateActionVar6[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]) 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 CastDelegateActionVar7[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]) 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 CastDelegateActionVar8[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]) 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 CastDelegateActionVar9[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]) 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 CastDelegateFunc0[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]) 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 CastDelegateFunc1[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]) 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 CastDelegateFunc10[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]) 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 CastDelegateFunc11[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]) 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 CastDelegateFunc12[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]) 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 CastDelegateFunc13[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]) 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 CastDelegateFunc14[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]) 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 CastDelegateFunc15[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]) 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 CastDelegateFunc16[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]) 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 CastDelegateFunc2[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]) 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 CastDelegateFunc3[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]) 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 CastDelegateFunc4[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]) 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 CastDelegateFunc5[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]) 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 CastDelegateFunc6[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]) 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 CastDelegateFunc7[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]) 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 CastDelegateFunc8[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]) 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 CastDelegateFunc9[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]) 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 CastDelegateFuncVar0[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]) 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 CastDelegateFuncVar1[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]) 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 CastDelegateFuncVar10[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]) 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 CastDelegateFuncVar11[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]) 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 CastDelegateFuncVar12[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]) 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 CastDelegateFuncVar13[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]) 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 CastDelegateFuncVar14[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]) 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 CastDelegateFuncVar15[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]) 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 CastDelegateFuncVar16[...](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]) 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 CastDelegateFuncVar2[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]) 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 CastDelegateFuncVar3[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]) 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 CastDelegateFuncVar4[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]) 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 CastDelegateFuncVar5[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]) 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 CastDelegateFuncVar6[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]) 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 CastDelegateFuncVar7[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]) 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 CastDelegateFuncVar8[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]) 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 CastDelegateFuncVar9[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]) 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 CastDelegatePairFunc0[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]) 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 CastDelegatePairFunc1[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]) 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 CastDelegatePairFunc10[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]) 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 CastDelegatePairFunc11[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]) 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 CastDelegatePairFunc12[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]) 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 CastDelegatePairFunc13[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]) 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 CastDelegatePairFunc14[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]) 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 CastDelegatePairFunc15[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]) 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 CastDelegatePairFunc16[...](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]) 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 CastDelegatePairFunc2[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]) 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 CastDelegatePairFunc3[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]) 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 CastDelegatePairFunc4[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]) 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 CastDelegatePairFunc5[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]) 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 CastDelegatePairFunc6[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]) 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 CastDelegatePairFunc7[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]) 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 CastDelegatePairFunc8[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]) 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 CastDelegatePairFunc9[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]) 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 CastDelegatePairFuncVar0[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]) 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 CastDelegatePairFuncVar1[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]) 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 CastDelegatePairFuncVar10[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]) 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 CastDelegatePairFuncVar11[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]) 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 CastDelegatePairFuncVar12[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]) 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 CastDelegatePairFuncVar13[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]) 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 CastDelegatePairFuncVar14[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]) 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 CastDelegatePairFuncVar15[...](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]) 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 CastDelegatePairFuncVar16[...](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]) 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 CastDelegatePairFuncVar2[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]) 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 CastDelegatePairFuncVar3[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]) 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 CastDelegatePairFuncVar4[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]) 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 CastDelegatePairFuncVar5[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]) 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 CastDelegatePairFuncVar6[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]) 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 CastDelegatePairFuncVar7[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]) 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 CastDelegatePairFuncVar8[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]) 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 CastDelegatePairFuncVar9[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]) 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 CastFunc0[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]) Exec() (r R)

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

+ type Func1 func(A1) R

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

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastFunc16[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]) 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 CastFunc2[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]) 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 CastFunc3[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]) 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 CastFunc4[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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastFunc8[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]) 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 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]

+ 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]) 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 CastFuncVar0[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]) Exec(va ...VA) (r R)

+ func (f FuncVar0[VA, R]) Invoke(va ...VA) (r R, panicErr error)

+ type FuncVar1 func(A1, ...VA) R

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

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastFuncVar15[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]) 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 CastFuncVar16[...](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]) 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 CastFuncVar2[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]) 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 CastFuncVar3[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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastFuncVar7[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]) 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 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]

+ 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]) 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 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]

+ 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]) 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 CastPairFunc0[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]) Exec() (r1 R1, r2 R2)

+ func (f PairFunc0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)

+ type PairFunc1 func(A1) (R1, R2)

+ func CastPairFunc1[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]) 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 CastPairFunc10[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]) 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 CastPairFunc11[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]) 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 CastPairFunc12[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]) 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 CastPairFunc13[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]) 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 CastPairFunc14[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]) 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 CastPairFunc15[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]) 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 CastPairFunc16[...](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]) 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 CastPairFunc2[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]) 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 CastPairFunc3[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]) 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 CastPairFunc4[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]) 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 CastPairFunc5[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]) 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 CastPairFunc6[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]) 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 CastPairFunc7[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]) 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 CastPairFunc8[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]) 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 CastPairFunc9[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]) 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 CastPairFuncVar0[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]) 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 CastPairFuncVar1[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]) 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 CastPairFuncVar10[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]) 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 CastPairFuncVar11[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]) 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 CastPairFuncVar12[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]) 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 CastPairFuncVar13[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]) 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 CastPairFuncVar14[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]) 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 CastPairFuncVar15[...](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]) 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 CastPairFuncVar16[...](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]) 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 CastPairFuncVar2[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]) 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 CastPairFuncVar3[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]) 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 CastPairFuncVar4[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]) 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 CastPairFuncVar5[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]) 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 CastPairFuncVar6[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]) 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 CastPairFuncVar7[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]) 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 CastPairFuncVar8[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]) 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 CastPairFuncVar9[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]) 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