generic

Documentation

Index

• func FuncError(err, panicErr error) error
• func FuncPairError[T any](r T, err, panicErr error) (T, error)
• type Action0
  • 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)
  • func (f Action0) ToDelegate() DelegateVoid0
• type Action1
  • 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)
  • func (f Action1[A1]) ToDelegate() DelegateVoid1[A1]
• type Action10
  • func CastAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, ...](f F) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
  • 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)
  • func (f Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ToDelegate() DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
• type Action11
  • func CastAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, ...](f F) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
  • 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)
  • func (f Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) ToDelegate() DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
• type Action12
  • func CastAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, ...](f F) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
  • 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)
  • func (f Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) ToDelegate() DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
• type Action13
  • func CastAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, ...](f F) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
  • 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)
  • func (f Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) ToDelegate() DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
• type Action14
  • func CastAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, ...](f F) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
  • 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)
  • func (f Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) ToDelegate() DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
• type Action15
  • func CastAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, ...](f F) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]
  • 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)
  • func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) ToDelegate() ...
• type Action16
  • 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)
  • func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) ToDelegate() ...
• type Action2
  • 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)
  • func (f Action2[A1, A2]) ToDelegate() DelegateVoid2[A1, A2]
• type Action3
  • 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)
  • func (f Action3[A1, A2, A3]) ToDelegate() DelegateVoid3[A1, A2, A3]
• type Action4
  • func CastAction4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](f F) Action4[A1, A2, A3, A4]
  • 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)
  • func (f Action4[A1, A2, A3, A4]) ToDelegate() DelegateVoid4[A1, A2, A3, A4]
• type Action5
  • func CastAction5[A1, A2, A3, A4, A5 any, F ~func(A1, A2, A3, A4, A5)](f F) Action5[A1, A2, A3, A4, A5]
  • 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)
  • func (f Action5[A1, A2, A3, A4, A5]) ToDelegate() DelegateVoid5[A1, A2, A3, A4, A5]
• type Action6
  • func CastAction6[A1, A2, A3, A4, A5, A6 any, F ~func(A1, A2, A3, A4, A5, A6)](f F) Action6[A1, A2, A3, A4, A5, A6]
  • 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)
  • func (f Action6[A1, A2, A3, A4, A5, A6]) ToDelegate() DelegateVoid6[A1, A2, A3, A4, A5, A6]
• type Action7
  • func CastAction7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(A1, A2, A3, A4, A5, A6, A7)](f F) Action7[A1, A2, A3, A4, A5, A6, A7]
  • 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)
  • func (f Action7[A1, A2, A3, A4, A5, A6, A7]) ToDelegate() DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]
• type Action8
  • func CastAction8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(A1, A2, A3, A4, A5, A6, A7, A8)](f F) Action8[A1, A2, A3, A4, A5, A6, A7, A8]
  • 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)
  • func (f Action8[A1, A2, A3, A4, A5, A6, A7, A8]) ToDelegate() DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]
• type Action9
  • func CastAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, ...](f F) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
  • 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)
  • func (f Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ToDelegate() DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
• type ActionVar0
  • func CastActionVar0[VA any, F ~func(...VA)](f F) ActionVar0[VA]
  • func (f ActionVar0[VA]) Call(autoRecover bool, reportError chan error, args ...VA) (panicErr error)
  • func (f ActionVar0[VA]) Exec(args ...VA)
  • func (f ActionVar0[VA]) Invoke(args ...VA) (panicErr error)
  • func (f ActionVar0[VA]) ToDelegate() DelegateVoidVar0[VA]
• type ActionVar1
  • 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, args ...VA) (panicErr error)
  • func (f ActionVar1[A1, VA]) Exec(a1 A1, args ...VA)
  • func (f ActionVar1[A1, VA]) Invoke(a1 A1, args ...VA) (panicErr error)
  • func (f ActionVar1[A1, VA]) ToDelegate() DelegateVoidVar1[A1, VA]
• type ActionVar10
  • func CastActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, ...](f F) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
  • 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)
  • func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) ToDelegate() DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
• type ActionVar11
  • func CastActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, ...](f F) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
  • 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)
  • func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) ToDelegate() DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
• type ActionVar12
  • func CastActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, ...](f F) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
  • 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)
  • func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) ToDelegate() DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
• type ActionVar13
  • func CastActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, ...](f F) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
  • 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)
  • func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) ToDelegate() DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
• type ActionVar14
  • func CastActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, ...](f F) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]
  • 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)
  • func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) ToDelegate() ...
• type ActionVar15
  • 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)
  • func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) ToDelegate() ...
• type ActionVar16
  • 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)
  • func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) ToDelegate() ...
• type ActionVar2
  • 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, args ...VA) (panicErr error)
  • func (f ActionVar2[A1, A2, VA]) Exec(a1 A1, a2 A2, args ...VA)
  • func (f ActionVar2[A1, A2, VA]) Invoke(a1 A1, a2 A2, args ...VA) (panicErr error)
  • func (f ActionVar2[A1, A2, VA]) ToDelegate() DelegateVoidVar2[A1, A2, VA]
• type ActionVar3
  • func CastActionVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](f F) ActionVar3[A1, A2, A3, VA]
  • func (f ActionVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)
  • func (f ActionVar3[A1, A2, A3, VA]) Exec(a1 A1, a2 A2, a3 A3, args ...VA)
  • func (f ActionVar3[A1, A2, A3, VA]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)
  • func (f ActionVar3[A1, A2, A3, VA]) ToDelegate() DelegateVoidVar3[A1, A2, A3, VA]
• type ActionVar4
  • func CastActionVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](f F) ActionVar4[A1, A2, A3, A4, VA]
  • func (f ActionVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, ...) (panicErr error)
  • func (f ActionVar4[A1, A2, A3, A4, VA]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA)
  • func (f ActionVar4[A1, A2, A3, A4, VA]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (panicErr error)
  • func (f ActionVar4[A1, A2, A3, A4, VA]) ToDelegate() DelegateVoidVar4[A1, A2, A3, A4, VA]
• type ActionVar5
  • func CastActionVar5[A1, A2, A3, A4, A5, VA any, F ~func(A1, A2, A3, A4, A5, ...VA)](f F) ActionVar5[A1, A2, A3, A4, A5, VA]
  • 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, args ...VA)
  • func (f ActionVar5[A1, A2, A3, A4, A5, VA]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (panicErr error)
  • func (f ActionVar5[A1, A2, A3, A4, A5, VA]) ToDelegate() DelegateVoidVar5[A1, A2, A3, A4, A5, VA]
• type ActionVar6
  • func CastActionVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(A1, A2, A3, A4, A5, A6, ...VA)](f F) ActionVar6[A1, A2, A3, A4, A5, A6, VA]
  • 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, args ...VA)
  • func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (panicErr error)
  • func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) ToDelegate() DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]
• type ActionVar7
  • func CastActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(A1, A2, A3, A4, A5, A6, A7, ...VA)](f F) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]
  • 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, args ...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, args ...VA) (panicErr error)
  • func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) ToDelegate() DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]
• type ActionVar8
  • func CastActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, ...](f F) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
  • 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, args ...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, args ...VA) (panicErr error)
  • func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) ToDelegate() DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
• type ActionVar9
  • func CastActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, ...](f F) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
  • 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, args ...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, args ...VA) (panicErr error)
  • func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) ToDelegate() DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
• type Delegate0
  • func CastDelegate0[R any, F ~func() R](fs ...F) Delegate0[R]
  • func (d Delegate0[R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool]) (r R, panicErr error)
  • func (d Delegate0[R]) Combine(f ...Func0[R]) Delegate0[R]
  • func (d Delegate0[R]) Exec(interrupt Func2[R, error, bool]) (r R)
  • func (d Delegate0[R]) Invoke(interrupt Func2[R, error, bool]) (r R, panicErr error)
  • func (d Delegate0[R]) ToFunc(interrupt Func2[R, error, bool]) Func0[R]
• type Delegate1
  • func CastDelegate1[A1, R any, F ~func(A1) R](fs ...F) Delegate1[A1, R]
  • func (d Delegate1[A1, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate1[A1, R]) Combine(f ...Func1[A1, R]) Delegate1[A1, R]
  • func (d Delegate1[A1, R]) Exec(interrupt Func2[R, error, bool], a1 A1) (r R)
  • func (d Delegate1[A1, R]) Invoke(interrupt Func2[R, error, bool], a1 A1) (r R, panicErr error)
  • func (d Delegate1[A1, R]) ToFunc(interrupt Func2[R, error, bool]) Func1[A1, R]
• type Delegate10
  • func CastDelegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](fs ...F) Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
  • func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Combine(f ...Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
  • func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) ToFunc(interrupt Func2[R, error, bool]) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
• type Delegate11
  • func CastDelegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](fs ...F) Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
  • func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Combine(f ...Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
  • func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) ToFunc(interrupt Func2[R, error, bool]) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
• type Delegate12
  • func CastDelegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](fs ...F) Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
  • func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Combine(f ...Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
  • func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) ToFunc(interrupt Func2[R, error, bool]) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
• type Delegate13
  • func CastDelegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, ...](fs ...F) Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
  • func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Combine(f ...Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
  • func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) ToFunc(interrupt Func2[R, error, bool]) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
• type Delegate14
  • func CastDelegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, ...](fs ...F) Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
  • func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Combine(f ...Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
  • func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) ToFunc(interrupt Func2[R, error, bool]) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
• type Delegate15
  • func CastDelegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, ...](fs ...F) ...
  • func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Combine(...) ...
  • func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) ToFunc(interrupt Func2[R, error, bool]) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]
• type Delegate16
  • func CastDelegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, ...](fs ...F) ...
  • func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Combine(...) ...
  • func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) ToFunc(interrupt Func2[R, error, bool]) ...
• type Delegate2
  • func CastDelegate2[A1, A2, R any, F ~func(A1, A2) R](fs ...F) Delegate2[A1, A2, R]
  • func (d Delegate2[A1, A2, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate2[A1, A2, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R)
  • func (d Delegate2[A1, A2, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R, panicErr error)
  • func (d Delegate2[A1, A2, R]) ToFunc(interrupt Func2[R, error, bool]) Func2[A1, A2, R]
• type Delegate3
  • func CastDelegate3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](fs ...F) Delegate3[A1, A2, A3, R]
  • func (d Delegate3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate3[A1, A2, A3, R]) Combine(f ...Func3[A1, A2, A3, R]) Delegate3[A1, A2, A3, R]
  • func (d Delegate3[A1, A2, A3, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R)
  • func (d Delegate3[A1, A2, A3, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R, panicErr error)
  • func (d Delegate3[A1, A2, A3, R]) ToFunc(interrupt Func2[R, error, bool]) Func3[A1, A2, A3, R]
• type Delegate4
  • func CastDelegate4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](fs ...F) Delegate4[A1, A2, A3, A4, R]
  • func (d Delegate4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate4[A1, A2, A3, A4, R]) Combine(f ...Func4[A1, A2, A3, A4, R]) Delegate4[A1, A2, A3, A4, R]
  • func (d Delegate4[A1, A2, A3, A4, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R)
  • func (d Delegate4[A1, A2, A3, A4, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)
  • func (d Delegate4[A1, A2, A3, A4, R]) ToFunc(interrupt Func2[R, error, bool]) Func4[A1, A2, A3, A4, R]
• type Delegate5
  • func CastDelegate5[A1, A2, A3, A4, A5, R any, F ~func(A1, A2, A3, A4, A5) R](fs ...F) Delegate5[A1, A2, A3, A4, A5, R]
  • func (d Delegate5[A1, A2, A3, A4, A5, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate5[A1, A2, A3, A4, A5, R]) Combine(f ...Func5[A1, A2, A3, A4, A5, R]) Delegate5[A1, A2, A3, A4, A5, R]
  • func (d Delegate5[A1, A2, A3, A4, A5, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R)
  • func (d Delegate5[A1, A2, A3, A4, A5, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R, panicErr error)
  • func (d Delegate5[A1, A2, A3, A4, A5, R]) ToFunc(interrupt Func2[R, error, bool]) Func5[A1, A2, A3, A4, A5, R]
• type Delegate6
  • func CastDelegate6[A1, A2, A3, A4, A5, A6, R any, F ~func(A1, A2, A3, A4, A5, A6) R](fs ...F) Delegate6[A1, A2, A3, A4, A5, A6, R]
  • func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) Combine(f ...Func6[A1, A2, A3, A4, A5, A6, R]) Delegate6[A1, A2, A3, A4, A5, A6, R]
  • func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r R)
  • func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r R, panicErr error)
  • func (d Delegate6[A1, A2, A3, A4, A5, A6, R]) ToFunc(interrupt Func2[R, error, bool]) Func6[A1, A2, A3, A4, A5, A6, R]
• type Delegate7
  • func CastDelegate7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(A1, A2, A3, A4, A5, A6, A7) R](fs ...F) Delegate7[A1, A2, A3, A4, A5, A6, A7, R]
  • func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Combine(f ...Func7[A1, A2, A3, A4, A5, A6, A7, R]) Delegate7[A1, A2, A3, A4, A5, A6, A7, R]
  • func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) ToFunc(interrupt Func2[R, error, bool]) Func7[A1, A2, A3, A4, A5, A6, A7, R]
• type Delegate8
  • func CastDelegate8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](fs ...F) Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]
  • func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Combine(f ...Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]
  • func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToFunc(interrupt Func2[R, error, bool]) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]
• type Delegate9
  • func CastDelegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](fs ...F) Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
  • func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Combine(f ...Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
  • func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToFunc(interrupt Func2[R, error, bool]) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
• type DelegatePair0
  • func CastDelegatePair0[R1, R2 any, F ~func() (R1, R2)](fs ...F) DelegatePair0[R1, R2]
  • func (d DelegatePair0[R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair0[R1, R2]) Combine(f ...FuncPair0[R1, R2]) DelegatePair0[R1, R2]
  • func (d DelegatePair0[R1, R2]) Exec(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2)
  • func (d DelegatePair0[R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair0[R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair0[R1, R2]
• type DelegatePair1
  • func CastDelegatePair1[A1, R1, R2 any, F ~func(A1) (R1, R2)](fs ...F) DelegatePair1[A1, R1, R2]
  • func (d DelegatePair1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair1[A1, R1, R2]) Combine(f ...FuncPair1[A1, R1, R2]) DelegatePair1[A1, R1, R2]
  • func (d DelegatePair1[A1, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2)
  • func (d DelegatePair1[A1, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair1[A1, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair1[A1, R1, R2]
• type DelegatePair10
  • func CastDelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](fs ...F) DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
  • func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Combine(f ...FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
  • func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
• type DelegatePair11
  • func CastDelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](fs ...F) DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
  • func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Combine(f ...FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
  • func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
• type DelegatePair12
  • func CastDelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](fs ...F) DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
  • func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Combine(f ...FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
  • func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
• type DelegatePair13
  • func CastDelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](fs ...F) DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
  • func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Combine(...) DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
  • func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
• type DelegatePair14
  • func CastDelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Combine(...) ...
  • func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePair15
  • func CastDelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Combine(...) ...
  • func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePair16
  • func CastDelegatePair16[...](fs ...F) ...
  • func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Combine(...) ...
  • func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePair2
  • func CastDelegatePair2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](fs ...F) DelegatePair2[A1, A2, R1, R2]
  • func (d DelegatePair2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair2[A1, A2, R1, R2]) Combine(f ...FuncPair2[A1, A2, R1, R2]) DelegatePair2[A1, A2, R1, R2]
  • func (d DelegatePair2[A1, A2, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2)
  • func (d DelegatePair2[A1, A2, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair2[A1, A2, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair2[A1, A2, R1, R2]
• type DelegatePair3
  • func CastDelegatePair3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](fs ...F) DelegatePair3[A1, A2, A3, R1, R2]
  • func (d DelegatePair3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair3[A1, A2, A3, R1, R2]) Combine(f ...FuncPair3[A1, A2, A3, R1, R2]) DelegatePair3[A1, A2, A3, R1, R2]
  • func (d DelegatePair3[A1, A2, A3, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)
  • func (d DelegatePair3[A1, A2, A3, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair3[A1, A2, A3, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair3[A1, A2, A3, R1, R2]
• type DelegatePair4
  • func CastDelegatePair4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](fs ...F) DelegatePair4[A1, A2, A3, A4, R1, R2]
  • func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) Combine(f ...FuncPair4[A1, A2, A3, A4, R1, R2]) DelegatePair4[A1, A2, A3, A4, R1, R2]
  • func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)
  • func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair4[A1, A2, A3, A4, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair4[A1, A2, A3, A4, R1, R2]
• type DelegatePair5
  • func CastDelegatePair5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(A1, A2, A3, A4, A5) (R1, R2)](fs ...F) DelegatePair5[A1, A2, A3, A4, A5, R1, R2]
  • func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Combine(f ...FuncPair5[A1, A2, A3, A4, A5, R1, R2]) DelegatePair5[A1, A2, A3, A4, A5, R1, R2]
  • func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)
  • func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair5[A1, A2, A3, A4, A5, R1, R2]
• type DelegatePair6
  • func CastDelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(A1, A2, A3, A4, A5, A6) (R1, R2)](fs ...F) DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]
  • func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Combine(f ...FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]
  • func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2)
  • func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]
• type DelegatePair7
  • func CastDelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](fs ...F) DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
  • func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Combine(f ...FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
  • func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
• type DelegatePair8
  • func CastDelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](fs ...F) DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
  • func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Combine(f ...FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
  • func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
• type DelegatePair9
  • func CastDelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](fs ...F) DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
  • func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Combine(f ...FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
  • func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
• type DelegatePairVar0
  • func CastDelegatePairVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairVar0[VA, R1, R2]
  • func (d DelegatePairVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar0[VA, R1, R2]) Combine(f ...FuncPairVar0[VA, R1, R2]) DelegatePairVar0[VA, R1, R2]
  • func (d DelegatePairVar0[VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairVar0[VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar0[VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar0[VA, R1, R2]
• type DelegatePairVar1
  • func CastDelegatePairVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](fs ...F) DelegatePairVar1[A1, VA, R1, R2]
  • func (d DelegatePairVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar1[A1, VA, R1, R2]) Combine(f ...FuncPairVar1[A1, VA, R1, R2]) DelegatePairVar1[A1, VA, R1, R2]
  • func (d DelegatePairVar1[A1, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairVar1[A1, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar1[A1, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar1[A1, VA, R1, R2]
• type DelegatePairVar10
  • func CastDelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](fs ...F) DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
  • func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Combine(f ...FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
  • func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
• type DelegatePairVar11
  • func CastDelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](fs ...F) DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
  • func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Combine(f ...FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
  • func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
• type DelegatePairVar12
  • func CastDelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Combine(...) ...
  • func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]
• type DelegatePairVar13
  • func CastDelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Combine(...) ...
  • func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairVar14
  • func CastDelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Combine(...) ...
  • func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairVar15
  • func CastDelegatePairVar15[...](fs ...F) ...
  • func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Combine(...) ...
  • func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairVar16
  • func CastDelegatePairVar16[...](fs ...F) ...
  • func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Combine(...) ...
  • func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairVar2
  • func CastDelegatePairVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](fs ...F) DelegatePairVar2[A1, A2, VA, R1, R2]
  • func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Combine(f ...FuncPairVar2[A1, A2, VA, R1, R2]) DelegatePairVar2[A1, A2, VA, R1, R2]
  • func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairVar2[A1, A2, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar2[A1, A2, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar2[A1, A2, VA, R1, R2]
• type DelegatePairVar3
  • func CastDelegatePairVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](fs ...F) DelegatePairVar3[A1, A2, A3, VA, R1, R2]
  • func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Combine(f ...FuncPairVar3[A1, A2, A3, VA, R1, R2]) DelegatePairVar3[A1, A2, A3, VA, R1, R2]
  • func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar3[A1, A2, A3, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar3[A1, A2, A3, VA, R1, R2]
• type DelegatePairVar4
  • func CastDelegatePairVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](fs ...F) DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]
  • func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Combine(f ...FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]
  • func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]
• type DelegatePairVar5
  • func CastDelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](fs ...F) DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]
  • func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Combine(f ...FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]
  • func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]
• type DelegatePairVar6
  • func CastDelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](fs ...F) DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
  • func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Combine(f ...FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
  • func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
• type DelegatePairVar7
  • func CastDelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](fs ...F) DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
  • func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Combine(f ...FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
  • func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
• type DelegatePairVar8
  • func CastDelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](fs ...F) DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
  • func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Combine(f ...FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
  • func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
• type DelegatePairVar9
  • func CastDelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](fs ...F) DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
  • func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Combine(f ...FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
  • func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
• type DelegateVar0
  • func CastDelegateVar0[VA, R any, F ~func(...VA) R](fs ...F) DelegateVar0[VA, R]
  • func (d DelegateVar0[VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar0[VA, R]) Combine(f ...FuncVar0[VA, R]) DelegateVar0[VA, R]
  • func (d DelegateVar0[VA, R]) Exec(interrupt Func2[R, error, bool], args ...VA) (r R)
  • func (d DelegateVar0[VA, R]) Invoke(interrupt Func2[R, error, bool], args ...VA) (r R, panicErr error)
  • func (d DelegateVar0[VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]
• type DelegateVar1
  • func CastDelegateVar1[A1, VA, R any, F ~func(A1, ...VA) R](fs ...F) DelegateVar1[A1, VA, R]
  • func (d DelegateVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar1[A1, VA, R]) Combine(f ...FuncVar1[A1, VA, R]) DelegateVar1[A1, VA, R]
  • func (d DelegateVar1[A1, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R)
  • func (d DelegateVar1[A1, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R, panicErr error)
  • func (d DelegateVar1[A1, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar1[A1, VA, R]
• type DelegateVar10
  • func CastDelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](fs ...F) DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
  • func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Combine(f ...FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
  • func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
• type DelegateVar11
  • func CastDelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](fs ...F) DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
  • func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Combine(f ...FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
  • func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
• type DelegateVar12
  • func CastDelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](fs ...F) DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
  • func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Combine(f ...FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
  • func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
• type DelegateVar13
  • func CastDelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](fs ...F) DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
  • func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Combine(f ...FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
  • func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
• type DelegateVar14
  • func CastDelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, ...](fs ...F) ...
  • func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Combine(...) ...
  • func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]
• type DelegateVar15
  • func CastDelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, ...](fs ...F) ...
  • func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Combine(...) ...
  • func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...
• type DelegateVar16
  • func CastDelegateVar16[...](fs ...F) ...
  • func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Combine(...) ...
  • func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...
• type DelegateVar2
  • func CastDelegateVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateVar2[A1, A2, VA, R]
  • func (d DelegateVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar2[A1, A2, VA, R]) Combine(f ...FuncVar2[A1, A2, VA, R]) DelegateVar2[A1, A2, VA, R]
  • func (d DelegateVar2[A1, A2, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R)
  • func (d DelegateVar2[A1, A2, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R, panicErr error)
  • func (d DelegateVar2[A1, A2, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]
• type DelegateVar3
  • func CastDelegateVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateVar3[A1, A2, A3, VA, R]
  • func (d DelegateVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar3[A1, A2, A3, VA, R]) Combine(f ...FuncVar3[A1, A2, A3, VA, R]) DelegateVar3[A1, A2, A3, VA, R]
  • func (d DelegateVar3[A1, A2, A3, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R)
  • func (d DelegateVar3[A1, A2, A3, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)
  • func (d DelegateVar3[A1, A2, A3, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]
• type DelegateVar4
  • func CastDelegateVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](fs ...F) DelegateVar4[A1, A2, A3, A4, VA, R]
  • func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Combine(f ...FuncVar4[A1, A2, A3, A4, VA, R]) DelegateVar4[A1, A2, A3, A4, VA, R]
  • func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)
  • func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)
  • func (d DelegateVar4[A1, A2, A3, A4, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]
• type DelegateVar5
  • func CastDelegateVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(A1, A2, A3, A4, A5, ...VA) R](fs ...F) DelegateVar5[A1, A2, A3, A4, A5, VA, R]
  • func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Combine(f ...FuncVar5[A1, A2, A3, A4, A5, VA, R]) DelegateVar5[A1, A2, A3, A4, A5, VA, R]
  • func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R)
  • func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R, panicErr error)
  • func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]
• type DelegateVar6
  • func CastDelegateVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(A1, A2, A3, A4, A5, A6, ...VA) R](fs ...F) DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]
  • func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Combine(f ...FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]
  • func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]
• type DelegateVar7
  • func CastDelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](fs ...F) DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
  • func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Combine(f ...FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
  • func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
• type DelegateVar8
  • func CastDelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](fs ...F) DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
  • func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Combine(f ...FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
  • func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
• type DelegateVar9
  • func CastDelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](fs ...F) DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
  • func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Combine(f ...FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
  • func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
• type DelegateVoid0
  • func CastDelegateVoid0[F ~func()](fs ...F) DelegateVoid0
  • func (d DelegateVoid0) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool]) (panicErr error)
  • func (d DelegateVoid0) Combine(f ...Action0) DelegateVoid0
  • func (d DelegateVoid0) Exec(interrupt Func1[error, bool])
  • func (d DelegateVoid0) Invoke(interrupt Func1[error, bool]) (panicErr error)
  • func (d DelegateVoid0) ToAction(interrupt Func1[error, bool]) Action0
• type DelegateVoid1
  • func CastDelegateVoid1[A1 any, F ~func(A1)](fs ...F) DelegateVoid1[A1]
  • func (d DelegateVoid1[A1]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1) (panicErr error)
  • func (d DelegateVoid1[A1]) Combine(f ...Action1[A1]) DelegateVoid1[A1]
  • func (d DelegateVoid1[A1]) Exec(interrupt Func1[error, bool], a1 A1)
  • func (d DelegateVoid1[A1]) Invoke(interrupt Func1[error, bool], a1 A1) (panicErr error)
  • func (d DelegateVoid1[A1]) ToAction(interrupt Func1[error, bool]) Action1[A1]
• type DelegateVoid10
  • func CastDelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, ...](fs ...F) DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
  • func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Combine(f ...Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
  • func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ToAction(interrupt Func1[error, bool]) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
• type DelegateVoid11
  • func CastDelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, ...](fs ...F) DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
  • func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Combine(f ...Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
  • func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) ToAction(interrupt Func1[error, bool]) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
• type DelegateVoid12
  • func CastDelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, ...](fs ...F) DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
  • func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Combine(f ...Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
  • func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) ToAction(interrupt Func1[error, bool]) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
• type DelegateVoid13
  • func CastDelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, ...](fs ...F) DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
  • func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Combine(f ...Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
  • func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) ToAction(interrupt Func1[error, bool]) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
• type DelegateVoid14
  • func CastDelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, ...](fs ...F) DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
  • func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Combine(f ...Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
  • func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) ToAction(interrupt Func1[error, bool]) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
• type DelegateVoid15
  • func CastDelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, ...](fs ...F) ...
  • func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Combine(...) ...
  • func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) ToAction(interrupt Func1[error, bool]) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]
• type DelegateVoid16
  • func CastDelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any, ...](fs ...F) ...
  • func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Combine(...) ...
  • func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) ToAction(interrupt Func1[error, bool]) ...
• type DelegateVoid2
  • func CastDelegateVoid2[A1, A2 any, F ~func(A1, A2)](fs ...F) DelegateVoid2[A1, A2]
  • func (d DelegateVoid2[A1, A2]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid2[A1, A2]) Combine(f ...Action2[A1, A2]) DelegateVoid2[A1, A2]
  • func (d DelegateVoid2[A1, A2]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2)
  • func (d DelegateVoid2[A1, A2]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)
  • func (d DelegateVoid2[A1, A2]) ToAction(interrupt Func1[error, bool]) Action2[A1, A2]
• type DelegateVoid3
  • func CastDelegateVoid3[A1, A2, A3 any, F ~func(A1, A2, A3)](fs ...F) DelegateVoid3[A1, A2, A3]
  • func (d DelegateVoid3[A1, A2, A3]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid3[A1, A2, A3]) Combine(f ...Action3[A1, A2, A3]) DelegateVoid3[A1, A2, A3]
  • func (d DelegateVoid3[A1, A2, A3]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3)
  • func (d DelegateVoid3[A1, A2, A3]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)
  • func (d DelegateVoid3[A1, A2, A3]) ToAction(interrupt Func1[error, bool]) Action3[A1, A2, A3]
• type DelegateVoid4
  • func CastDelegateVoid4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](fs ...F) DelegateVoid4[A1, A2, A3, A4]
  • func (d DelegateVoid4[A1, A2, A3, A4]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid4[A1, A2, A3, A4]) Combine(f ...Action4[A1, A2, A3, A4]) DelegateVoid4[A1, A2, A3, A4]
  • func (d DelegateVoid4[A1, A2, A3, A4]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4)
  • func (d DelegateVoid4[A1, A2, A3, A4]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)
  • func (d DelegateVoid4[A1, A2, A3, A4]) ToAction(interrupt Func1[error, bool]) Action4[A1, A2, A3, A4]
• type DelegateVoid5
  • func CastDelegateVoid5[A1, A2, A3, A4, A5 any, F ~func(A1, A2, A3, A4, A5)](fs ...F) DelegateVoid5[A1, A2, A3, A4, A5]
  • func (d DelegateVoid5[A1, A2, A3, A4, A5]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid5[A1, A2, A3, A4, A5]) Combine(f ...Action5[A1, A2, A3, A4, A5]) DelegateVoid5[A1, A2, A3, A4, A5]
  • func (d DelegateVoid5[A1, A2, A3, A4, A5]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5)
  • func (d DelegateVoid5[A1, A2, A3, A4, A5]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (panicErr error)
  • func (d DelegateVoid5[A1, A2, A3, A4, A5]) ToAction(interrupt Func1[error, bool]) Action5[A1, A2, A3, A4, A5]
• type DelegateVoid6
  • func CastDelegateVoid6[A1, A2, A3, A4, A5, A6 any, F ~func(A1, A2, A3, A4, A5, A6)](fs ...F) DelegateVoid6[A1, A2, A3, A4, A5, A6]
  • func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Combine(f ...Action6[A1, A2, A3, A4, A5, A6]) DelegateVoid6[A1, A2, A3, A4, A5, A6]
  • func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6)
  • func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (panicErr error)
  • func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) ToAction(interrupt Func1[error, bool]) Action6[A1, A2, A3, A4, A5, A6]
• type DelegateVoid7
  • func CastDelegateVoid7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(A1, A2, A3, A4, A5, A6, A7)](fs ...F) DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]
  • func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Combine(f ...Action7[A1, A2, A3, A4, A5, A6, A7]) DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]
  • func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7)
  • func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (panicErr error)
  • func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) ToAction(interrupt Func1[error, bool]) Action7[A1, A2, A3, A4, A5, A6, A7]
• type DelegateVoid8
  • func CastDelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(A1, A2, A3, A4, A5, A6, A7, A8)](fs ...F) DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]
  • func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Combine(f ...Action8[A1, A2, A3, A4, A5, A6, A7, A8]) DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]
  • func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) ToAction(interrupt Func1[error, bool]) Action8[A1, A2, A3, A4, A5, A6, A7, A8]
• type DelegateVoid9
  • func CastDelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, ...](fs ...F) DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
  • func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Combine(f ...Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
  • func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ToAction(interrupt Func1[error, bool]) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
• type DelegateVoidVar0
  • func CastDelegateVoidVar0[VA any, F ~func(...VA)](fs ...F) DelegateVoidVar0[VA]
  • func (d DelegateVoidVar0[VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], ...) (panicErr error)
  • func (d DelegateVoidVar0[VA]) Combine(f ...ActionVar0[VA]) DelegateVoidVar0[VA]
  • func (d DelegateVoidVar0[VA]) Exec(interrupt Func1[error, bool], args ...VA)
  • func (d DelegateVoidVar0[VA]) Invoke(interrupt Func1[error, bool], args ...VA) (panicErr error)
  • func (d DelegateVoidVar0[VA]) ToAction(interrupt Func1[error, bool]) ActionVar0[VA]
• type DelegateVoidVar1
  • func CastDelegateVoidVar1[A1, VA, F ~func(A1, ...VA)](fs ...F) DelegateVoidVar1[A1, VA]
  • func (d DelegateVoidVar1[A1, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar1[A1, VA]) Combine(f ...ActionVar1[A1, VA]) DelegateVoidVar1[A1, VA]
  • func (d DelegateVoidVar1[A1, VA]) Exec(interrupt Func1[error, bool], a1 A1, args ...VA)
  • func (d DelegateVoidVar1[A1, VA]) Invoke(interrupt Func1[error, bool], a1 A1, args ...VA) (panicErr error)
  • func (d DelegateVoidVar1[A1, VA]) ToAction(interrupt Func1[error, bool]) ActionVar1[A1, VA]
• type DelegateVoidVar10
  • func CastDelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, ...](fs ...F) DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
  • func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Combine(f ...ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
  • func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) ToAction(interrupt Func1[error, bool]) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
• type DelegateVoidVar11
  • func CastDelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, ...](fs ...F) DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
  • func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Combine(f ...ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
  • func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) ToAction(interrupt Func1[error, bool]) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
• type DelegateVoidVar12
  • func CastDelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, ...](fs ...F) DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
  • func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Combine(f ...ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
  • func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) ToAction(interrupt Func1[error, bool]) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
• type DelegateVoidVar13
  • func CastDelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, ...](fs ...F) DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
  • func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Combine(f ...ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
  • func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) ToAction(interrupt Func1[error, bool]) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
• type DelegateVoidVar14
  • func CastDelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, ...](fs ...F) ...
  • func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Combine(...) ...
  • func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) ToAction(interrupt Func1[error, bool]) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]
• type DelegateVoidVar15
  • func CastDelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any, ...](fs ...F) ...
  • func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Combine(...) ...
  • func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) ToAction(interrupt Func1[error, bool]) ...
• type DelegateVoidVar16
  • func CastDelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any, ...](fs ...F) ...
  • func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Combine(...) ...
  • func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) ToAction(interrupt Func1[error, bool]) ...
• type DelegateVoidVar2
  • func CastDelegateVoidVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](fs ...F) DelegateVoidVar2[A1, A2, VA]
  • func (d DelegateVoidVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar2[A1, A2, VA]) Combine(f ...ActionVar2[A1, A2, VA]) DelegateVoidVar2[A1, A2, VA]
  • func (d DelegateVoidVar2[A1, A2, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA)
  • func (d DelegateVoidVar2[A1, A2, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA) (panicErr error)
  • func (d DelegateVoidVar2[A1, A2, VA]) ToAction(interrupt Func1[error, bool]) ActionVar2[A1, A2, VA]
• type DelegateVoidVar3
  • func CastDelegateVoidVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](fs ...F) DelegateVoidVar3[A1, A2, A3, VA]
  • func (d DelegateVoidVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar3[A1, A2, A3, VA]) Combine(f ...ActionVar3[A1, A2, A3, VA]) DelegateVoidVar3[A1, A2, A3, VA]
  • func (d DelegateVoidVar3[A1, A2, A3, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA)
  • func (d DelegateVoidVar3[A1, A2, A3, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)
  • func (d DelegateVoidVar3[A1, A2, A3, VA]) ToAction(interrupt Func1[error, bool]) ActionVar3[A1, A2, A3, VA]
• type DelegateVoidVar4
  • func CastDelegateVoidVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](fs ...F) DelegateVoidVar4[A1, A2, A3, A4, VA]
  • func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Combine(f ...ActionVar4[A1, A2, A3, A4, VA]) DelegateVoidVar4[A1, A2, A3, A4, VA]
  • func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA)
  • func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (panicErr error)
  • func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) ToAction(interrupt Func1[error, bool]) ActionVar4[A1, A2, A3, A4, VA]
• type DelegateVoidVar5
  • func CastDelegateVoidVar5[A1, A2, A3, A4, A5, VA any, F ~func(A1, A2, A3, A4, A5, ...VA)](fs ...F) DelegateVoidVar5[A1, A2, A3, A4, A5, VA]
  • func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Combine(f ...ActionVar5[A1, A2, A3, A4, A5, VA]) DelegateVoidVar5[A1, A2, A3, A4, A5, VA]
  • func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA)
  • func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (panicErr error)
  • func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) ToAction(interrupt Func1[error, bool]) ActionVar5[A1, A2, A3, A4, A5, VA]
• type DelegateVoidVar6
  • func CastDelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(A1, A2, A3, A4, A5, A6, ...VA)](fs ...F) DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]
  • func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Combine(f ...ActionVar6[A1, A2, A3, A4, A5, A6, VA]) DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]
  • func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...)
  • func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (panicErr error)
  • func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) ToAction(interrupt Func1[error, bool]) ActionVar6[A1, A2, A3, A4, A5, A6, VA]
• type DelegateVoidVar7
  • func CastDelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(A1, A2, A3, A4, A5, A6, A7, ...VA)](fs ...F) DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]
  • func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Combine(f ...ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]
  • func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) ToAction(interrupt Func1[error, bool]) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]
• type DelegateVoidVar8
  • func CastDelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, ...](fs ...F) DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
  • func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Combine(f ...ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
  • func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) ToAction(interrupt Func1[error, bool]) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
• type DelegateVoidVar9
  • func CastDelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, ...](fs ...F) DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
  • func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Combine(f ...ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
  • func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) ToAction(interrupt Func1[error, bool]) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
• type Func0
  • func CastFunc0[R any, F ~func() R](f F) Func0[R]
  • 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)
  • func (f Func0[R]) ToDelegate() Delegate0[R]
• type Func1
  • 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)
  • func (f Func1[A1, R]) ToDelegate() Delegate1[A1, R]
• type Func10
  • func CastFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
  • 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)
  • func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) ToDelegate() Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
• type Func11
  • func CastFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
  • 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)
  • func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) ToDelegate() Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
• type Func12
  • func CastFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
  • 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)
  • func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) ToDelegate() Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
• type Func13
  • func CastFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, ...](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
  • 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)
  • func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) ToDelegate() Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
• type Func14
  • func CastFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, ...](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
  • 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)
  • func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) ToDelegate() Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
• type Func15
  • func CastFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, ...](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]
  • 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)
  • func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) ToDelegate() ...
• type Func16
  • 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)
  • func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) ToDelegate() ...
• type Func2
  • 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)
  • func (f Func2[A1, A2, R]) ToDelegate() Delegate2[A1, A2, R]
• type Func3
  • func CastFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]
  • 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)
  • func (f Func3[A1, A2, A3, R]) ToDelegate() Delegate3[A1, A2, A3, R]
• type Func4
  • func CastFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]
  • 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)
  • func (f Func4[A1, A2, A3, A4, R]) ToDelegate() Delegate4[A1, A2, A3, A4, R]
• type Func5
  • func CastFunc5[A1, A2, A3, A4, A5, R any, F ~func(A1, A2, A3, A4, A5) R](f F) Func5[A1, A2, A3, A4, A5, R]
  • 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)
  • func (f Func5[A1, A2, A3, A4, A5, R]) ToDelegate() Delegate5[A1, A2, A3, A4, A5, R]
• type Func6
  • func CastFunc6[A1, A2, A3, A4, A5, A6, R any, F ~func(A1, A2, A3, A4, A5, A6) R](f F) Func6[A1, A2, A3, A4, A5, A6, R]
  • 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)
  • func (f Func6[A1, A2, A3, A4, A5, A6, R]) ToDelegate() Delegate6[A1, A2, A3, A4, A5, A6, R]
• type Func7
  • func CastFunc7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(A1, A2, A3, A4, A5, A6, A7) R](f F) Func7[A1, A2, A3, A4, A5, A6, A7, R]
  • 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)
  • func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) ToDelegate() Delegate7[A1, A2, A3, A4, A5, A6, A7, R]
• type Func8
  • func CastFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]
  • 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)
  • func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToDelegate() Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]
• type Func9
  • func CastFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
  • 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)
  • func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToDelegate() Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
• type FuncPair0
  • func CastFuncPair0[R1, R2 any, F ~func() (R1, R2)](f F) FuncPair0[R1, R2]
  • func (f FuncPair0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair0[R1, R2]) Exec() (r1 R1, r2 R2)
  • func (f FuncPair0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair0[R1, R2]) ToDelegate() DelegatePair0[R1, R2]
• type FuncPair1
  • func CastFuncPair1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) FuncPair1[A1, R1, R2]
  • func (f FuncPair1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)
  • func (f FuncPair1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair1[A1, R1, R2]) ToDelegate() DelegatePair1[A1, R1, R2]
• type FuncPair10
  • func CastFuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](f F) FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
  • func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10) (r1 R1, r2 R2)
  • func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate() DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
• type FuncPair11
  • func CastFuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](f F) FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
  • func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate() DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
• type FuncPair12
  • func CastFuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](f F) FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
  • func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate() DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
• type FuncPair13
  • func CastFuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](f F) FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
  • func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate() DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
• type FuncPair14
  • func CastFuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](f F) ...
  • func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate() ...
• type FuncPair15
  • func CastFuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](f F) ...
  • func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate() ...
• type FuncPair16
  • func CastFuncPair16[...](f F) ...
  • func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate() ...
• type FuncPair2
  • func CastFuncPair2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) FuncPair2[A1, A2, R1, R2]
  • func (f FuncPair2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)
  • func (f FuncPair2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair2[A1, A2, R1, R2]) ToDelegate() DelegatePair2[A1, A2, R1, R2]
• type FuncPair3
  • func CastFuncPair3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) FuncPair3[A1, A2, A3, R1, R2]
  • func (f FuncPair3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)
  • func (f FuncPair3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair3[A1, A2, A3, R1, R2]) ToDelegate() DelegatePair3[A1, A2, A3, R1, R2]
• type FuncPair4
  • func CastFuncPair4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](f F) FuncPair4[A1, A2, A3, A4, R1, R2]
  • func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)
  • func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair4[A1, A2, A3, A4, R1, R2]) ToDelegate() DelegatePair4[A1, A2, A3, A4, R1, R2]
• type FuncPair5
  • func CastFuncPair5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(A1, A2, A3, A4, A5) (R1, R2)](f F) FuncPair5[A1, A2, A3, A4, A5, R1, R2]
  • func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)
  • func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate() DelegatePair5[A1, A2, A3, A4, A5, R1, R2]
• type FuncPair6
  • func CastFuncPair6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(A1, A2, A3, A4, A5, A6) (R1, R2)](f F) FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]
  • func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2)
  • func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate() DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]
• type FuncPair7
  • func CastFuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](f F) FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
  • func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r1 R1, r2 R2)
  • func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate() DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
• type FuncPair8
  • func CastFuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](f F) FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
  • func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r1 R1, r2 R2)
  • func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate() DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
• type FuncPair9
  • func CastFuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](f F) FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
  • func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r1 R1, r2 R2)
  • func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate() DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
• type FuncPairVar0
  • func CastFuncPairVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) FuncPairVar0[VA, R1, R2]
  • func (f FuncPairVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar0[VA, R1, R2]) Exec(args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar0[VA, R1, R2]) Invoke(args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar0[VA, R1, R2]) ToDelegate() DelegatePairVar0[VA, R1, R2]
• type FuncPairVar1
  • func CastFuncPairVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) FuncPairVar1[A1, VA, R1, R2]
  • func (f FuncPairVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar1[A1, VA, R1, R2]) Exec(a1 A1, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar1[A1, VA, R1, R2]) Invoke(a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar1[A1, VA, R1, R2]) ToDelegate() DelegatePairVar1[A1, VA, R1, R2]
• type FuncPairVar10
  • func CastFuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](f F) FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
  • func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate() DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
• type FuncPairVar11
  • func CastFuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](f F) FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
  • func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate() DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
• type FuncPairVar12
  • func CastFuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](f F) FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]
  • func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate() ...
• type FuncPairVar13
  • func CastFuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](f F) ...
  • func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate() ...
• type FuncPairVar14
  • func CastFuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](f F) ...
  • func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate() ...
• type FuncPairVar15
  • func CastFuncPairVar15[...](f F) ...
  • func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate() ...
• type FuncPairVar16
  • func CastFuncPairVar16[...](f F) ...
  • func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate() ...
• type FuncPairVar2
  • func CastFuncPairVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) FuncPairVar2[A1, A2, VA, R1, R2]
  • func (f FuncPairVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar2[A1, A2, VA, R1, R2]) ToDelegate() DelegatePairVar2[A1, A2, VA, R1, R2]
• type FuncPairVar3
  • func CastFuncPairVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](f F) FuncPairVar3[A1, A2, A3, VA, R1, R2]
  • func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) ToDelegate() DelegatePairVar3[A1, A2, A3, VA, R1, R2]
• type FuncPairVar4
  • func CastFuncPairVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](f F) FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]
  • func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate() DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]
• type FuncPairVar5
  • func CastFuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](f F) FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]
  • func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate() DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]
• type FuncPairVar6
  • func CastFuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](f F) FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
  • func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate() DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
• type FuncPairVar7
  • func CastFuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](f F) FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
  • func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate() DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
• type FuncPairVar8
  • func CastFuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](f F) FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
  • func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate() DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
• type FuncPairVar9
  • func CastFuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](f F) FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
  • func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r1 R1, r2 R2)
  • func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate() DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
• type FuncVar0
  • func CastFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]
  • func (f FuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, args ...VA) (r R, panicErr error)
  • func (f FuncVar0[VA, R]) Exec(args ...VA) (r R)
  • func (f FuncVar0[VA, R]) Invoke(args ...VA) (r R, panicErr error)
  • func (f FuncVar0[VA, R]) ToDelegate() DelegateVar0[VA, R]
• type FuncVar1
  • 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, args ...VA) (r R, panicErr error)
  • func (f FuncVar1[A1, VA, R]) Exec(a1 A1, args ...VA) (r R)
  • func (f FuncVar1[A1, VA, R]) Invoke(a1 A1, args ...VA) (r R, panicErr error)
  • func (f FuncVar1[A1, VA, R]) ToDelegate() DelegateVar1[A1, VA, R]
• type FuncVar10
  • func CastFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
  • 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)
  • func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToDelegate() DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
• type FuncVar11
  • func CastFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
  • 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)
  • func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToDelegate() DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
• type FuncVar12
  • func CastFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
  • 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)
  • func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToDelegate() DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
• type FuncVar13
  • func CastFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
  • 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)
  • func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToDelegate() DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
• type FuncVar14
  • func CastFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, ...](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]
  • 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)
  • func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToDelegate() ...
• type FuncVar15
  • 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)
  • func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToDelegate() ...
• type FuncVar16
  • 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)
  • func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToDelegate() ...
• type FuncVar2
  • func 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, args ...VA) (r R, panicErr error)
  • func (f FuncVar2[A1, A2, VA, R]) Exec(a1 A1, a2 A2, args ...VA) (r R)
  • func (f FuncVar2[A1, A2, VA, R]) Invoke(a1 A1, a2 A2, args ...VA) (r R, panicErr error)
  • func (f FuncVar2[A1, A2, VA, R]) ToDelegate() DelegateVar2[A1, A2, VA, R]
• type FuncVar3
  • func CastFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]
  • func (f FuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)
  • func (f FuncVar3[A1, A2, A3, VA, R]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r R)
  • func (f FuncVar3[A1, A2, A3, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)
  • func (f FuncVar3[A1, A2, A3, VA, R]) ToDelegate() DelegateVar3[A1, A2, A3, VA, R]
• type FuncVar4
  • func CastFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](f F) FuncVar4[A1, A2, A3, A4, VA, R]
  • func (f FuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, ...) (r R, panicErr error)
  • func (f FuncVar4[A1, A2, A3, A4, VA, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)
  • func (f FuncVar4[A1, A2, A3, A4, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)
  • func (f FuncVar4[A1, A2, A3, A4, VA, R]) ToDelegate() DelegateVar4[A1, A2, A3, A4, VA, R]
• type FuncVar5
  • func CastFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(A1, A2, A3, A4, A5, ...VA) R](f F) FuncVar5[A1, A2, A3, A4, A5, VA, R]
  • 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, args ...VA) (r R)
  • func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R, panicErr error)
  • func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) ToDelegate() DelegateVar5[A1, A2, A3, A4, A5, VA, R]
• type FuncVar6
  • func CastFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(A1, A2, A3, A4, A5, A6, ...VA) R](f F) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]
  • 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, args ...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, args ...VA) (r R, panicErr error)
  • func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToDelegate() DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]
• type FuncVar7
  • func CastFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
  • 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, args ...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, args ...VA) (r R, panicErr error)
  • func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToDelegate() DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
• type FuncVar8
  • func CastFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
  • 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, args ...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, args ...VA) (r R, panicErr error)
  • func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToDelegate() DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
• type FuncVar9
  • func CastFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
  • 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, args ...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, args ...VA) (r R, panicErr error)
  • func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToDelegate() DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
• type KV
• type List
  • func NewList[T any]() *List[T]
  • func (l *List[T]) Back() *Node[T]
  • func (l *List[T]) Front() *Node[T]
  • func (l *List[T]) InsertAfter(value T, at *Node[T]) *Node[T]
  • func (l *List[T]) InsertBefore(value T, at *Node[T]) *Node[T]
  • func (l *List[T]) Len() int
  • func (l *List[T]) MoveAfter(n, at *Node[T])
  • func (l *List[T]) MoveBefore(n, at *Node[T])
  • func (l *List[T]) MoveToBack(n *Node[T])
  • func (l *List[T]) MoveToFront(n *Node[T])
  • func (l *List[T]) PushBack(value T) *Node[T]
  • func (l *List[T]) PushBackList(other *List[T])
  • func (l *List[T]) PushFront(value T) *Node[T]
  • func (l *List[T]) PushFrontList(other *List[T])
  • func (l *List[T]) Remove(n *Node[T])
  • func (l *List[T]) ReversedTraversal(visitor func(n *Node[T]) bool)
  • func (l *List[T]) ReversedTraversalAt(visitor func(n *Node[T]) bool, at *Node[T])
  • func (l *List[T]) Traversal(visitor func(n *Node[T]) bool)
  • func (l *List[T]) TraversalAt(visitor func(n *Node[T]) bool, at *Node[T])
  • func (l *List[T]) Version() int64
• type Node
  • func (n *Node[T]) Escape()
  • func (n *Node[T]) Escaped() bool
  • func (n *Node[T]) Next() *Node[T]
  • func (n *Node[T]) Prev() *Node[T]
  • func (n *Node[T]) Version() int64
• type SliceMap
  • func MakeSliceMap[K cmp.Ordered, V any](kvs ...KV[K, V]) SliceMap[K, V]
  • func MakeSliceMapFromGoMap[K cmp.Ordered, V any](m map[K]V) SliceMap[K, V]
  • func NewSliceMap[K cmp.Ordered, V any](kvs ...KV[K, V]) *SliceMap[K, V]
  • func NewSliceMapFromGoMap[K cmp.Ordered, V any](m map[K]V) *SliceMap[K, V]
  • func (m *SliceMap[K, V]) Add(k K, v V)
  • func (m SliceMap[K, V]) Clone() SliceMap[K, V]
  • func (m *SliceMap[K, V]) Delete(k K) bool
  • func (m SliceMap[K, V]) Each(fun Action2[K, V])
  • func (m SliceMap[K, V]) Exist(k K) bool
  • func (m SliceMap[K, V]) Get(k K) (V, bool)
  • func (m SliceMap[K, V]) Index(k K) int
  • func (m SliceMap[K, V]) Keys() []K
  • func (m SliceMap[K, V]) Len() int
  • func (m SliceMap[K, V]) Range(fun Func2[K, V, bool])
  • func (m SliceMap[K, V]) ReversedEach(fun Action2[K, V])
  • func (m SliceMap[K, V]) ReversedRange(fun Func2[K, V, bool])
  • func (m SliceMap[K, V]) ToGoMap() map[K]V
  • func (m SliceMap[K, V]) ToUnorderedSliceMap() UnorderedSliceMap[K, V]
  • func (m *SliceMap[K, V]) TryAdd(k K, v V) bool
  • func (m SliceMap[K, V]) Value(k K) V
  • func (m SliceMap[K, V]) Values() []V
• type UnorderedKV
• type UnorderedSliceMap
  • func MakeUnorderedSliceMap[K comparable, V any](kvs ...UnorderedKV[K, V]) UnorderedSliceMap[K, V]
  • func MakeUnorderedSliceMapFromGoMap[K comparable, V any](m map[K]V) UnorderedSliceMap[K, V]
  • func NewUnorderedSliceMap[K comparable, V any](kvs ...UnorderedKV[K, V]) *UnorderedSliceMap[K, V]
  • func NewUnorderedSliceMapFromGoMap[K comparable, V any](m map[K]V) *UnorderedSliceMap[K, V]
  • func (m *UnorderedSliceMap[K, V]) Add(k K, v V)
  • func (m UnorderedSliceMap[K, V]) Clone() UnorderedSliceMap[K, V]
  • func (m *UnorderedSliceMap[K, V]) Delete(k K) bool
  • func (m UnorderedSliceMap[K, V]) Each(fun Action2[K, V])
  • func (m UnorderedSliceMap[K, V]) Exist(k K) bool
  • func (m UnorderedSliceMap[K, V]) Get(k K) (V, bool)
  • func (m UnorderedSliceMap[K, V]) Index(k K) int
  • func (m UnorderedSliceMap[K, V]) Keys() []K
  • func (m UnorderedSliceMap[K, V]) Len() int
  • func (m UnorderedSliceMap[K, V]) Range(fun Func2[K, V, bool])
  • func (m UnorderedSliceMap[K, V]) ReversedEach(fun Action2[K, V])
  • func (m UnorderedSliceMap[K, V]) ReversedRange(fun Func2[K, V, bool])
  • func (m UnorderedSliceMap[K, V]) ToGoMap() map[K]V
  • func (m *UnorderedSliceMap[K, V]) TryAdd(k K, v V) bool
  • func (m UnorderedSliceMap[K, V]) Value(k K) V
  • func (m UnorderedSliceMap[K, V]) Values() []V

Functions

func FuncError

func FuncError(err, panicErr error) error

func FuncPairError

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

Types

type Action0

type Action0 func()

func CastAction0

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

func (Action0) Call

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

func (Action0) Exec

func (f Action0) Exec()

func (Action0) Invoke

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

func (Action0) ToDelegate

func (f Action0) ToDelegate() DelegateVoid0

type Action1

type Action1[A1 any] func(A1)

func CastAction1

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

func (Action1[A1]) Call

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

func (Action1[A1]) Exec

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

func (Action1[A1]) Invoke

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

func (Action1[A1]) ToDelegate

func (f Action1[A1]) ToDelegate() DelegateVoid1[A1]

type Action10

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

func CastAction10

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

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

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

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

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

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

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

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

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

type Action11

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

func CastAction11

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

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

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

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

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

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

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

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

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

type Action12

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

func CastAction12

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

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

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

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

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

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

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

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

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

type Action13

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

func CastAction13

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

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

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

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

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

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

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

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

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

type Action14

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

func CastAction14

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

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

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

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

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

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

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

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

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

type Action15

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

func CastAction15

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

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

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

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

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

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

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

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

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

type Action16

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

func CastAction16

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

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

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

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

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

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

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

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

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

type Action2

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

func CastAction2

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

func (Action2[A1, A2]) Call

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

func (Action2[A1, A2]) Exec

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

func (Action2[A1, A2]) Invoke

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

func (Action2[A1, A2]) ToDelegate

func (f Action2[A1, A2]) ToDelegate() DelegateVoid2[A1, A2]

type Action3

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

func CastAction3

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

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

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

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

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

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

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

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

func (f Action3[A1, A2, A3]) ToDelegate() DelegateVoid3[A1, A2, A3]

type Action4

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

func CastAction4

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

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

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

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

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

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

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

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

func (f Action4[A1, A2, A3, A4]) ToDelegate() DelegateVoid4[A1, A2, A3, A4]

type Action5

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

func CastAction5

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

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

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

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

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

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

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

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

func (f Action5[A1, A2, A3, A4, A5]) ToDelegate() DelegateVoid5[A1, A2, A3, A4, A5]

type Action6

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

func CastAction6

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 (Action6[A1, A2, A3, A4, A5, A6]) Call

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

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

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

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

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

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

func (f Action6[A1, A2, A3, A4, A5, A6]) ToDelegate() DelegateVoid6[A1, A2, A3, A4, A5, A6]

type Action7

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

func CastAction7

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

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

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

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

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

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

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

func (f Action7[A1, A2, A3, A4, A5, A6, A7]) ToDelegate() DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]

type Action8

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

func CastAction8

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

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

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

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

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

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

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

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

type Action9

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

func CastAction9

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

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

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

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

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

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

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

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

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

type ActionVar0

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

func CastActionVar0

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

func (ActionVar0[VA]) Call

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

func (ActionVar0[VA]) Exec

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

func (ActionVar0[VA]) Invoke

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

func (ActionVar0[VA]) ToDelegate

func (f ActionVar0[VA]) ToDelegate() DelegateVoidVar0[VA]

type ActionVar1

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

func CastActionVar1

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

func (ActionVar1[A1, VA]) Call

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

func (ActionVar1[A1, VA]) Exec

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

func (ActionVar1[A1, VA]) Invoke

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

func (ActionVar1[A1, VA]) ToDelegate

func (f ActionVar1[A1, VA]) ToDelegate() DelegateVoidVar1[A1, VA]

type ActionVar10

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

func CastActionVar10

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

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

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

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

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

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

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

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

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

type ActionVar11

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

func CastActionVar11

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

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

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

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

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

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

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

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

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

type ActionVar12

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

func CastActionVar12

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

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

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

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

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

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

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

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

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

type ActionVar13

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

func CastActionVar13

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

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

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

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

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

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

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

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

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

type ActionVar14

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

func CastActionVar14

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

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

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

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

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

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

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

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

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

type ActionVar15

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

func CastActionVar15

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

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

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

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

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

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

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

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

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

type ActionVar16

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

func CastActionVar16

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

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

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

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

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

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

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

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

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

type ActionVar2

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

func CastActionVar2

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

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

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

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

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

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

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

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

func (f ActionVar2[A1, A2, VA]) ToDelegate() DelegateVoidVar2[A1, A2, VA]

type ActionVar3

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

func CastActionVar3

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

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

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

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

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

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

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

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

func (f ActionVar3[A1, A2, A3, VA]) ToDelegate() DelegateVoidVar3[A1, A2, A3, VA]

type ActionVar4

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

func CastActionVar4

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

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

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

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

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

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

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

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

func (f ActionVar4[A1, A2, A3, A4, VA]) ToDelegate() DelegateVoidVar4[A1, A2, A3, A4, VA]

type ActionVar5

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

func CastActionVar5

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 (ActionVar5[A1, A2, A3, A4, A5, VA]) Call

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

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

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

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

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

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

func (f ActionVar5[A1, A2, A3, A4, A5, VA]) ToDelegate() DelegateVoidVar5[A1, A2, A3, A4, A5, VA]

type ActionVar6

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

func CastActionVar6

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

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

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

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

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

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

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

func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) ToDelegate() DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]

type ActionVar7

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

func CastActionVar7

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

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

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

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

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

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

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

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

type ActionVar8

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

func CastActionVar8

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

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

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

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

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

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

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

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

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

type ActionVar9

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

func CastActionVar9

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

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

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

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

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

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

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

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

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

type Delegate0

type Delegate0[R any] []Func0[R]

func CastDelegate0

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

func (Delegate0[R]) Call

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

func (Delegate0[R]) Combine

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

func (Delegate0[R]) Exec

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

func (Delegate0[R]) Invoke

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

func (Delegate0[R]) ToFunc

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

type Delegate1

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

func CastDelegate1

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

func (Delegate1[A1, R]) Call

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

func (Delegate1[A1, R]) Combine

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

func (Delegate1[A1, R]) Exec

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

func (Delegate1[A1, R]) Invoke

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

func (Delegate1[A1, R]) ToFunc

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

type Delegate10

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

func CastDelegate10

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

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

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

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

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

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

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

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

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

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

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

type Delegate11

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

func CastDelegate11

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

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

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

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

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

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

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

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

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

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

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

type Delegate12

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

func CastDelegate12

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

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

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

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

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

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

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

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

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

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

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

type Delegate13

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

func CastDelegate13

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

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

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

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

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

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

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

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

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

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

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

type Delegate14

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

func CastDelegate14

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

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

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

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

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

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

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

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

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

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

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

type Delegate15

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

func CastDelegate15

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

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

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

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

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

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

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

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

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

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

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

type Delegate16

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

func CastDelegate16

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

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

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

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

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

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

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

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

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

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

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

type Delegate2

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

func CastDelegate2

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

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

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

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

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

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

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

func (Delegate2[A1, A2, R]) ToFunc

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

type Delegate3

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

func CastDelegate3

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

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

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

func (Delegate3[A1, A2, A3, R]) Combine

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

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

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

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

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

func (Delegate3[A1, A2, A3, R]) ToFunc

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

type Delegate4

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

func CastDelegate4

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

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

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

func (Delegate4[A1, A2, A3, A4, R]) Combine

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

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

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

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

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

func (Delegate4[A1, A2, A3, A4, R]) ToFunc

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

type Delegate5

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

func CastDelegate5

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

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

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

func (Delegate5[A1, A2, A3, A4, A5, R]) Combine

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

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

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

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

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

func (Delegate5[A1, A2, A3, A4, A5, R]) ToFunc

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

type Delegate6

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

func CastDelegate6

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

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

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

func (Delegate6[A1, A2, A3, A4, A5, A6, R]) Combine

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

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

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

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

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

func (Delegate6[A1, A2, A3, A4, A5, A6, R]) ToFunc

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

type Delegate7

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

func CastDelegate7

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

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

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

func (Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) Combine

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

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

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

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

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

func (Delegate7[A1, A2, A3, A4, A5, A6, A7, R]) ToFunc

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

type Delegate8

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

func CastDelegate8

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

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

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

func (Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Combine

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

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

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

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

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

func (Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToFunc

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

type Delegate9

type Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any] []Func9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, R,
]

func CastDelegate9

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

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

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

func (Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Combine

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

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

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

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

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

func (Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToFunc

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

type DelegatePair0

type DelegatePair0[R1, R2 any] []FuncPair0[R1, R2]

func CastDelegatePair0

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

func (DelegatePair0[R1, R2]) Call

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

func (DelegatePair0[R1, R2]) Combine

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

func (DelegatePair0[R1, R2]) Exec

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

func (DelegatePair0[R1, R2]) Invoke

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

func (DelegatePair0[R1, R2]) ToFunc

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

type DelegatePair1

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

func CastDelegatePair1

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

func (DelegatePair1[A1, R1, R2]) Call

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

func (DelegatePair1[A1, R1, R2]) Combine

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

func (DelegatePair1[A1, R1, R2]) Exec

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

func (DelegatePair1[A1, R1, R2]) Invoke

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

func (DelegatePair1[A1, R1, R2]) ToFunc

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

type DelegatePair10

type DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any] []FuncPair10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2,
]

func CastDelegatePair10

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

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

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

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

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

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

func (d DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2)

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

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

func (DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToFunc

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

type DelegatePair11

type DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any] []FuncPair11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2,
]

func CastDelegatePair11

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

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

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

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

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

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

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

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

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

func (DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToFunc

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

type DelegatePair12

type DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any] []FuncPair12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2,
]

func CastDelegatePair12

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

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

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

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

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

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

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

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

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

func (DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToFunc

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

type DelegatePair13

type DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any] []FuncPair13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2,
]

func CastDelegatePair13

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

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

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

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

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

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

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

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

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

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

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

type DelegatePair14

type DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any] []FuncPair14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2,
]

func CastDelegatePair14

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

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

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

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

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

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

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

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

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

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

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

type DelegatePair15

type DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any] []FuncPair15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2,
]

func CastDelegatePair15

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

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

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

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

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

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

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

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

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

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

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

type DelegatePair16

type DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any] []FuncPair16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2,
]

func CastDelegatePair16

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

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

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

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

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

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

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

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

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

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

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

type DelegatePair2

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

func CastDelegatePair2

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

func (DelegatePair2[A1, A2, R1, R2]) Call

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

func (DelegatePair2[A1, A2, R1, R2]) Combine

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

func (DelegatePair2[A1, A2, R1, R2]) Exec

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

func (DelegatePair2[A1, A2, R1, R2]) Invoke

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

func (DelegatePair2[A1, A2, R1, R2]) ToFunc

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

type DelegatePair3

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

func CastDelegatePair3

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

func (DelegatePair3[A1, A2, A3, R1, R2]) Call

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

func (DelegatePair3[A1, A2, A3, R1, R2]) Combine

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

func (DelegatePair3[A1, A2, A3, R1, R2]) Exec

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

func (DelegatePair3[A1, A2, A3, R1, R2]) Invoke

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

func (DelegatePair3[A1, A2, A3, R1, R2]) ToFunc

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

type DelegatePair4

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

func CastDelegatePair4

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

func (DelegatePair4[A1, A2, A3, A4, R1, R2]) Call

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

func (DelegatePair4[A1, A2, A3, A4, R1, R2]) Combine

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

func (DelegatePair4[A1, A2, A3, A4, R1, R2]) Exec

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

func (DelegatePair4[A1, A2, A3, A4, R1, R2]) Invoke

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

func (DelegatePair4[A1, A2, A3, A4, R1, R2]) ToFunc

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

type DelegatePair5

type DelegatePair5[A1, A2, A3, A4, A5, R1, R2 any] []FuncPair5[
	A1, A2, A3, A4, A5, R1, R2,
]

func CastDelegatePair5

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

func (DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Call

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

func (DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Combine

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

func (DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Exec

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

func (DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) Invoke

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

func (DelegatePair5[A1, A2, A3, A4, A5, R1, R2]) ToFunc

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

type DelegatePair6

type DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2 any] []FuncPair6[
	A1, A2, A3, A4, A5, A6, R1, R2,
]

func CastDelegatePair6

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

func (DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call

func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Combine

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

func (DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec

func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2)

func (DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke

func (d DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc

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

type DelegatePair7

type DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any] []FuncPair7[
	A1, A2, A3, A4, A5, A6, A7, R1, R2,
]

func CastDelegatePair7

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

func (DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call

func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Combine

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

func (DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec

func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2)

func (DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke

func (d DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc

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

type DelegatePair8

type DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any] []FuncPair8[
	A1, A2, A3, A4, A5, A6, A7, A8, R1, R2,
]

func CastDelegatePair8

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

func (DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call

func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Combine

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

func (DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec

func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2)

func (DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke

func (d DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc

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

type DelegatePair9

type DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any] []FuncPair9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2,
]

func CastDelegatePair9

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

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

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

func (DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Combine

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

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

func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2)

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

func (d DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc

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

type DelegatePairVar0

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

func CastDelegatePairVar0

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

func (DelegatePairVar0[VA, R1, R2]) Call

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

func (DelegatePairVar0[VA, R1, R2]) Combine

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

func (DelegatePairVar0[VA, R1, R2]) Exec

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

func (DelegatePairVar0[VA, R1, R2]) Invoke

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

func (DelegatePairVar0[VA, R1, R2]) ToFunc

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

type DelegatePairVar1

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

func CastDelegatePairVar1

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

func (DelegatePairVar1[A1, VA, R1, R2]) Call

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

func (DelegatePairVar1[A1, VA, R1, R2]) Combine

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

func (DelegatePairVar1[A1, VA, R1, R2]) Exec

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

func (DelegatePairVar1[A1, VA, R1, R2]) Invoke

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

func (DelegatePairVar1[A1, VA, R1, R2]) ToFunc

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

type DelegatePairVar10

type DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any] []FuncPairVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2,
]

func CastDelegatePairVar10

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

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

func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

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

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

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

func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2)

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

func (d DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc

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

type DelegatePairVar11

type DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any] []FuncPairVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2,
]

func CastDelegatePairVar11

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

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

func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

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

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

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

func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2)

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

func (d DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc

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

type DelegatePairVar12

type DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any] []FuncPairVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2,
]

func CastDelegatePairVar12

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

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

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

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

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

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

func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2)

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

func (d DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

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

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

type DelegatePairVar13

type DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any] []FuncPairVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2,
]

func CastDelegatePairVar13

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

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

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

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

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

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

func (d DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2)

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

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

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

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

type DelegatePairVar14

type DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any] []FuncPairVar14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2,
]

func CastDelegatePairVar14

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

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

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

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

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

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

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

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

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

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

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

type DelegatePairVar15

type DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any] []FuncPairVar15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2,
]

func CastDelegatePairVar15

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

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

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

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

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

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

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

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

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

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

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

type DelegatePairVar16

type DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any] []FuncPairVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2,
]

func CastDelegatePairVar16

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

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

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

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

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

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

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

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

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

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

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

type DelegatePairVar2

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

func CastDelegatePairVar2

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

func (DelegatePairVar2[A1, A2, VA, R1, R2]) Call

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

func (DelegatePairVar2[A1, A2, VA, R1, R2]) Combine

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

func (DelegatePairVar2[A1, A2, VA, R1, R2]) Exec

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

func (DelegatePairVar2[A1, A2, VA, R1, R2]) Invoke

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

func (DelegatePairVar2[A1, A2, VA, R1, R2]) ToFunc

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

type DelegatePairVar3

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

func CastDelegatePairVar3

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

func (DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Call

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

func (DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Combine

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

func (DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Exec

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

func (DelegatePairVar3[A1, A2, A3, VA, R1, R2]) Invoke

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

func (DelegatePairVar3[A1, A2, A3, VA, R1, R2]) ToFunc

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

type DelegatePairVar4

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

func CastDelegatePairVar4

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

func (DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Call

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

func (DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Combine

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

func (DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec

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

func (DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke

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

func (DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc

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

type DelegatePairVar5

type DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any] []FuncPairVar5[
	A1, A2, A3, A4, A5, VA, R1, R2,
]

func CastDelegatePairVar5

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

func (DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call

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

func (DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Combine

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

func (DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec

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

func (DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke

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

func (DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc

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

type DelegatePairVar6

type DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any] []FuncPairVar6[
	A1, A2, A3, A4, A5, A6, VA, R1, R2,
]

func CastDelegatePairVar6

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

func (DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call

func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Combine

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

func (DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec

func (d DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke

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

func (DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc

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

type DelegatePairVar7

type DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any] []FuncPairVar7[
	A1, A2, A3, A4, A5, A6, A7, VA, R1, R2,
]

func CastDelegatePairVar7

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

func (DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call

func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Combine

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

func (DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec

func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke

func (d DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc

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

type DelegatePairVar8

type DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any] []FuncPairVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2,
]

func CastDelegatePairVar8

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

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

func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Combine

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

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

func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2)

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

func (d DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc

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

type DelegatePairVar9

type DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any] []FuncPairVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2,
]

func CastDelegatePairVar9

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

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

func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

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

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

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

func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2)

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

func (d DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc

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

type DelegateVar0

type DelegateVar0[VA, R any] []FuncVar0[VA, R]

func CastDelegateVar0

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

func (DelegateVar0[VA, R]) Call

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

func (DelegateVar0[VA, R]) Combine

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

func (DelegateVar0[VA, R]) Exec

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

func (DelegateVar0[VA, R]) Invoke

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

func (DelegateVar0[VA, R]) ToFunc

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

type DelegateVar1

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

func CastDelegateVar1

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

func (DelegateVar1[A1, VA, R]) Call

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

func (DelegateVar1[A1, VA, R]) Combine

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

func (DelegateVar1[A1, VA, R]) Exec

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

func (DelegateVar1[A1, VA, R]) Invoke

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

func (DelegateVar1[A1, VA, R]) ToFunc

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

type DelegateVar10

type DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any] []FuncVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R,
]

func CastDelegateVar10

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

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

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

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

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

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

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

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

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

func (DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToFunc

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

type DelegateVar11

type DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any] []FuncVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R,
]

func CastDelegateVar11

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

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

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

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

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

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

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

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

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

func (DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToFunc

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

type DelegateVar12

type DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any] []FuncVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R,
]

func CastDelegateVar12

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

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

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

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

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

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

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

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

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

func (DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToFunc

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

type DelegateVar13

type DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any] []FuncVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R,
]

func CastDelegateVar13

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

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

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

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

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

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

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

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

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

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

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

type DelegateVar14

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

func CastDelegateVar14

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

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

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

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

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

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

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

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

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

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

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

type DelegateVar15

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

func CastDelegateVar15

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

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

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

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

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

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

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

func (DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke

func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r R, panicErr error)

func (DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToFunc

func (d DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

type DelegateVar16

type DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any] []FuncVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R,
]

func CastDelegateVar16

func CastDelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R](fs ...F) DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call

func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r R, panicErr error)

func (DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Combine

func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Combine(f ...FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec

func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r R)

func (DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke

func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r R, panicErr error)

func (DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToFunc

func (d DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

type DelegateVar2

type DelegateVar2[A1, A2, VA, R any] []FuncVar2[A1, A2, VA, R]

func CastDelegateVar2

func CastDelegateVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateVar2[A1, A2, VA, R]

func (DelegateVar2[A1, A2, VA, R]) Call

func (d DelegateVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R, panicErr error)

func (DelegateVar2[A1, A2, VA, R]) Combine

func (d DelegateVar2[A1, A2, VA, R]) Combine(f ...FuncVar2[A1, A2, VA, R]) DelegateVar2[A1, A2, VA, R]

func (DelegateVar2[A1, A2, VA, R]) Exec

func (d DelegateVar2[A1, A2, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R)

func (DelegateVar2[A1, A2, VA, R]) Invoke

func (d DelegateVar2[A1, A2, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R, panicErr error)

func (DelegateVar2[A1, A2, VA, R]) ToFunc

func (d DelegateVar2[A1, A2, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]

type DelegateVar3

type DelegateVar3[A1, A2, A3, VA, R any] []FuncVar3[A1, A2, A3, VA, R]

func CastDelegateVar3

func CastDelegateVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateVar3[A1, A2, A3, VA, R]

func (DelegateVar3[A1, A2, A3, VA, R]) Call

func (d DelegateVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

func (DelegateVar3[A1, A2, A3, VA, R]) Combine

func (d DelegateVar3[A1, A2, A3, VA, R]) Combine(f ...FuncVar3[A1, A2, A3, VA, R]) DelegateVar3[A1, A2, A3, VA, R]

func (DelegateVar3[A1, A2, A3, VA, R]) Exec

func (d DelegateVar3[A1, A2, A3, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R)

func (DelegateVar3[A1, A2, A3, VA, R]) Invoke

func (d DelegateVar3[A1, A2, A3, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

func (DelegateVar3[A1, A2, A3, VA, R]) ToFunc

func (d DelegateVar3[A1, A2, A3, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]

type DelegateVar4

type DelegateVar4[A1, A2, A3, A4, VA, R any] []FuncVar4[A1, A2, A3, A4, VA, R]

func CastDelegateVar4

func CastDelegateVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](fs ...F) DelegateVar4[A1, A2, A3, A4, VA, R]

func (DelegateVar4[A1, A2, A3, A4, VA, R]) Call

func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

func (DelegateVar4[A1, A2, A3, A4, VA, R]) Combine

func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Combine(f ...FuncVar4[A1, A2, A3, A4, VA, R]) DelegateVar4[A1, A2, A3, A4, VA, R]

func (DelegateVar4[A1, A2, A3, A4, VA, R]) Exec

func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)

func (DelegateVar4[A1, A2, A3, A4, VA, R]) Invoke

func (d DelegateVar4[A1, A2, A3, A4, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

func (DelegateVar4[A1, A2, A3, A4, VA, R]) ToFunc

func (d DelegateVar4[A1, A2, A3, A4, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]

type DelegateVar5

type DelegateVar5[A1, A2, A3, A4, A5, VA, R any] []FuncVar5[
	A1, A2, A3, A4, A5, VA, R,
]

func CastDelegateVar5

func CastDelegateVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) R](fs ...F) DelegateVar5[A1, A2, A3, A4, A5, VA, R]

func (DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Call

func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r R, panicErr error)

func (DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Combine

func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Combine(f ...FuncVar5[A1, A2, A3, A4, A5, VA, R]) DelegateVar5[A1, A2, A3, A4, A5, VA, R]

func (DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Exec

func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r R)

func (DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Invoke

func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r R, panicErr error)

func (DelegateVar5[A1, A2, A3, A4, A5, VA, R]) ToFunc

func (d DelegateVar5[A1, A2, A3, A4, A5, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]

type DelegateVar6

type DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R any] []FuncVar6[
	A1, A2, A3, A4, A5, A6, VA, R,
]

func CastDelegateVar6

func CastDelegateVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R](fs ...F) DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call

func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r R, panicErr error)

func (DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Combine

func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Combine(f ...FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec

func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r R)

func (DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke

func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r R, panicErr error)

func (DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToFunc

func (d DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

type DelegateVar7

type DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any] []FuncVar7[
	A1, A2, A3, A4, A5, A6, A7, VA, R,
]

func CastDelegateVar7

func CastDelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R](fs ...F) DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call

func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r R, panicErr error)

func (DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Combine

func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Combine(f ...FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec

func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r R)

func (DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke

func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r R, panicErr error)

func (DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToFunc

func (d DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

type DelegateVar8

type DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any] []FuncVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA, R,
]

func CastDelegateVar8

func CastDelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R](fs ...F) DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call

func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r R, panicErr error)

func (DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Combine

func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Combine(f ...FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec

func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r R)

func (DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke

func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r R, panicErr error)

func (DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToFunc

func (d DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

type DelegateVar9

type DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any] []FuncVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R,
]

func CastDelegateVar9

func CastDelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R](fs ...F) DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call

func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(
	autoRecover bool, reportError chan error, interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r R, panicErr error)

func (DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Combine

func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Combine(f ...FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec

func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r R)

func (DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke

func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke(interrupt Func2[R, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r R, panicErr error)

func (DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToFunc

func (d DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

type DelegateVoid0

type DelegateVoid0 []Action0

func CastDelegateVoid0

func CastDelegateVoid0[F ~func()](fs ...F) DelegateVoid0

func (DelegateVoid0) Call

func (d DelegateVoid0) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool]) (panicErr error)

func (DelegateVoid0) Combine

func (d DelegateVoid0) Combine(f ...Action0) DelegateVoid0

func (DelegateVoid0) Exec

func (d DelegateVoid0) Exec(interrupt Func1[error, bool])

func (DelegateVoid0) Invoke

func (d DelegateVoid0) Invoke(interrupt Func1[error, bool]) (panicErr error)

func (DelegateVoid0) ToAction

func (d DelegateVoid0) ToAction(interrupt Func1[error, bool]) Action0

type DelegateVoid1

type DelegateVoid1[A1 any] []Action1[A1]

func CastDelegateVoid1

func CastDelegateVoid1[A1 any, F ~func(A1)](fs ...F) DelegateVoid1[A1]

func (DelegateVoid1[A1]) Call

func (d DelegateVoid1[A1]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1) (panicErr error)

func (DelegateVoid1[A1]) Combine

func (d DelegateVoid1[A1]) Combine(f ...Action1[A1]) DelegateVoid1[A1]

func (DelegateVoid1[A1]) Exec

func (d DelegateVoid1[A1]) Exec(interrupt Func1[error, bool], a1 A1)

func (DelegateVoid1[A1]) Invoke

func (d DelegateVoid1[A1]) Invoke(interrupt Func1[error, bool], a1 A1) (panicErr error)

func (DelegateVoid1[A1]) ToAction

func (d DelegateVoid1[A1]) ToAction(interrupt Func1[error, bool]) Action1[A1]

type DelegateVoid10

type DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any] []Action10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
]

func CastDelegateVoid10

func CastDelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
)](fs ...F) DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

func (DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call

func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (panicErr error)

func (DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Combine

func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Combine(f ...Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

func (DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec

func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
)

func (DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke

func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (panicErr error)

func (DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ToAction

func (d DelegateVoid10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ToAction(interrupt Func1[error, bool]) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]

type DelegateVoid11

type DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any] []Action11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
]

func CastDelegateVoid11

func CastDelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
)](fs ...F) DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

func (DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call

func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (panicErr error)

func (DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Combine

func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Combine(f ...Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

func (DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec

func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
)

func (DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke

func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (panicErr error)

func (DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) ToAction

func (d DelegateVoid11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) ToAction(interrupt Func1[error, bool]) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]

type DelegateVoid12

type DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any] []Action12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
]

func CastDelegateVoid12

func CastDelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
)](fs ...F) DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

func (DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call

func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (panicErr error)

func (DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Combine

func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Combine(f ...Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

func (DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec

func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
)

func (DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke

func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (panicErr error)

func (DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) ToAction

func (d DelegateVoid12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) ToAction(interrupt Func1[error, bool]) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]

type DelegateVoid13

type DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any] []Action13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
]

func CastDelegateVoid13

func CastDelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
)](fs ...F) DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

func (DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call

func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (panicErr error)

func (DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Combine

func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Combine(f ...Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

func (DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec

func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
)

func (DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke

func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (panicErr error)

func (DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) ToAction

func (d DelegateVoid13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) ToAction(interrupt Func1[error, bool]) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]

type DelegateVoid14

type DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any] []Action14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
]

func CastDelegateVoid14

func CastDelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
)](fs ...F) DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

func (DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call

func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (panicErr error)

func (DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Combine

func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Combine(f ...Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

func (DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec

func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
)

func (DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke

func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (panicErr error)

func (DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) ToAction

func (d DelegateVoid14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) ToAction(interrupt Func1[error, bool]) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]

type DelegateVoid15

type DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any] []Action15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
]

func CastDelegateVoid15

func CastDelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
)](fs ...F) DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

func (DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call

func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (panicErr error)

func (DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Combine

func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Combine(f ...Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

func (DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec

func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
)

func (DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke

func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (panicErr error)

func (DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) ToAction

func (d DelegateVoid15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) ToAction(interrupt Func1[error, bool]) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]

type DelegateVoid16

type DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any] []Action16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
]

func CastDelegateVoid16

func CastDelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
)](fs ...F) DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

func (DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call

func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (panicErr error)

func (DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Combine

func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Combine(f ...Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

func (DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec

func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
)

func (DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke

func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (panicErr error)

func (DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) ToAction

func (d DelegateVoid16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) ToAction(interrupt Func1[error, bool]) Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]

type DelegateVoid2

type DelegateVoid2[A1, A2 any] []Action2[A1, A2]

func CastDelegateVoid2

func CastDelegateVoid2[A1, A2 any, F ~func(A1, A2)](fs ...F) DelegateVoid2[A1, A2]

func (DelegateVoid2[A1, A2]) Call

func (d DelegateVoid2[A1, A2]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)

func (DelegateVoid2[A1, A2]) Combine

func (d DelegateVoid2[A1, A2]) Combine(f ...Action2[A1, A2]) DelegateVoid2[A1, A2]

func (DelegateVoid2[A1, A2]) Exec

func (d DelegateVoid2[A1, A2]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2)

func (DelegateVoid2[A1, A2]) Invoke

func (d DelegateVoid2[A1, A2]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)

func (DelegateVoid2[A1, A2]) ToAction

func (d DelegateVoid2[A1, A2]) ToAction(interrupt Func1[error, bool]) Action2[A1, A2]

type DelegateVoid3

type DelegateVoid3[A1, A2, A3 any] []Action3[A1, A2, A3]

func CastDelegateVoid3

func CastDelegateVoid3[A1, A2, A3 any, F ~func(A1, A2, A3)](fs ...F) DelegateVoid3[A1, A2, A3]

func (DelegateVoid3[A1, A2, A3]) Call

func (d DelegateVoid3[A1, A2, A3]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)

func (DelegateVoid3[A1, A2, A3]) Combine

func (d DelegateVoid3[A1, A2, A3]) Combine(f ...Action3[A1, A2, A3]) DelegateVoid3[A1, A2, A3]

func (DelegateVoid3[A1, A2, A3]) Exec

func (d DelegateVoid3[A1, A2, A3]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3)

func (DelegateVoid3[A1, A2, A3]) Invoke

func (d DelegateVoid3[A1, A2, A3]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)

func (DelegateVoid3[A1, A2, A3]) ToAction

func (d DelegateVoid3[A1, A2, A3]) ToAction(interrupt Func1[error, bool]) Action3[A1, A2, A3]

type DelegateVoid4

type DelegateVoid4[A1, A2, A3, A4 any] []Action4[A1, A2, A3, A4]

func CastDelegateVoid4

func CastDelegateVoid4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](fs ...F) DelegateVoid4[A1, A2, A3, A4]

func (DelegateVoid4[A1, A2, A3, A4]) Call

func (d DelegateVoid4[A1, A2, A3, A4]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)

func (DelegateVoid4[A1, A2, A3, A4]) Combine

func (d DelegateVoid4[A1, A2, A3, A4]) Combine(f ...Action4[A1, A2, A3, A4]) DelegateVoid4[A1, A2, A3, A4]

func (DelegateVoid4[A1, A2, A3, A4]) Exec

func (d DelegateVoid4[A1, A2, A3, A4]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4)

func (DelegateVoid4[A1, A2, A3, A4]) Invoke

func (d DelegateVoid4[A1, A2, A3, A4]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)

func (DelegateVoid4[A1, A2, A3, A4]) ToAction

func (d DelegateVoid4[A1, A2, A3, A4]) ToAction(interrupt Func1[error, bool]) Action4[A1, A2, A3, A4]

type DelegateVoid5

type DelegateVoid5[A1, A2, A3, A4, A5 any] []Action5[
	A1, A2, A3, A4, A5,
]

func CastDelegateVoid5

func CastDelegateVoid5[A1, A2, A3, A4, A5 any, F ~func(
	A1, A2, A3, A4, A5,
)](fs ...F) DelegateVoid5[A1, A2, A3, A4, A5]

func (DelegateVoid5[A1, A2, A3, A4, A5]) Call

func (d DelegateVoid5[A1, A2, A3, A4, A5]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (panicErr error)

func (DelegateVoid5[A1, A2, A3, A4, A5]) Combine

func (d DelegateVoid5[A1, A2, A3, A4, A5]) Combine(f ...Action5[A1, A2, A3, A4, A5]) DelegateVoid5[A1, A2, A3, A4, A5]

func (DelegateVoid5[A1, A2, A3, A4, A5]) Exec

func (d DelegateVoid5[A1, A2, A3, A4, A5]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
)

func (DelegateVoid5[A1, A2, A3, A4, A5]) Invoke

func (d DelegateVoid5[A1, A2, A3, A4, A5]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (panicErr error)

func (DelegateVoid5[A1, A2, A3, A4, A5]) ToAction

func (d DelegateVoid5[A1, A2, A3, A4, A5]) ToAction(interrupt Func1[error, bool]) Action5[A1, A2, A3, A4, A5]

type DelegateVoid6

type DelegateVoid6[A1, A2, A3, A4, A5, A6 any] []Action6[
	A1, A2, A3, A4, A5, A6,
]

func CastDelegateVoid6

func CastDelegateVoid6[A1, A2, A3, A4, A5, A6 any, F ~func(
	A1, A2, A3, A4, A5, A6,
)](fs ...F) DelegateVoid6[A1, A2, A3, A4, A5, A6]

func (DelegateVoid6[A1, A2, A3, A4, A5, A6]) Call

func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (panicErr error)

func (DelegateVoid6[A1, A2, A3, A4, A5, A6]) Combine

func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Combine(f ...Action6[A1, A2, A3, A4, A5, A6]) DelegateVoid6[A1, A2, A3, A4, A5, A6]

func (DelegateVoid6[A1, A2, A3, A4, A5, A6]) Exec

func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
)

func (DelegateVoid6[A1, A2, A3, A4, A5, A6]) Invoke

func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (panicErr error)

func (DelegateVoid6[A1, A2, A3, A4, A5, A6]) ToAction

func (d DelegateVoid6[A1, A2, A3, A4, A5, A6]) ToAction(interrupt Func1[error, bool]) Action6[A1, A2, A3, A4, A5, A6]

type DelegateVoid7

type DelegateVoid7[A1, A2, A3, A4, A5, A6, A7 any] []Action7[
	A1, A2, A3, A4, A5, A6, A7,
]

func CastDelegateVoid7

func CastDelegateVoid7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
)](fs ...F) DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]

func (DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Call

func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (panicErr error)

func (DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Combine

func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Combine(f ...Action7[A1, A2, A3, A4, A5, A6, A7]) DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]

func (DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Exec

func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
)

func (DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Invoke

func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (panicErr error)

func (DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) ToAction

func (d DelegateVoid7[A1, A2, A3, A4, A5, A6, A7]) ToAction(interrupt Func1[error, bool]) Action7[A1, A2, A3, A4, A5, A6, A7]

type DelegateVoid8

type DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8 any] []Action8[
	A1, A2, A3, A4, A5, A6, A7, A8,
]

func CastDelegateVoid8

func CastDelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
)](fs ...F) DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]

func (DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Call

func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (panicErr error)

func (DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Combine

func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Combine(f ...Action8[A1, A2, A3, A4, A5, A6, A7, A8]) DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]

func (DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec

func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
)

func (DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke

func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (panicErr error)

func (DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) ToAction

func (d DelegateVoid8[A1, A2, A3, A4, A5, A6, A7, A8]) ToAction(interrupt Func1[error, bool]) Action8[A1, A2, A3, A4, A5, A6, A7, A8]

type DelegateVoid9

type DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any] []Action9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
]

func CastDelegateVoid9

func CastDelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
)](fs ...F) DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

func (DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call

func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (panicErr error)

func (DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Combine

func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Combine(f ...Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

func (DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec

func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
)

func (DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke

func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (panicErr error)

func (DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ToAction

func (d DelegateVoid9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ToAction(interrupt Func1[error, bool]) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]

type DelegateVoidVar0

type DelegateVoidVar0[VA any] []ActionVar0[VA]

func CastDelegateVoidVar0

func CastDelegateVoidVar0[VA any, F ~func(...VA)](fs ...F) DelegateVoidVar0[VA]

func (DelegateVoidVar0[VA]) Call

func (d DelegateVoidVar0[VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], args ...VA) (panicErr error)

func (DelegateVoidVar0[VA]) Combine

func (d DelegateVoidVar0[VA]) Combine(f ...ActionVar0[VA]) DelegateVoidVar0[VA]

func (DelegateVoidVar0[VA]) Exec

func (d DelegateVoidVar0[VA]) Exec(interrupt Func1[error, bool], args ...VA)

func (DelegateVoidVar0[VA]) Invoke

func (d DelegateVoidVar0[VA]) Invoke(interrupt Func1[error, bool], args ...VA) (panicErr error)

func (DelegateVoidVar0[VA]) ToAction

func (d DelegateVoidVar0[VA]) ToAction(interrupt Func1[error, bool]) ActionVar0[VA]

type DelegateVoidVar1

type DelegateVoidVar1[A1, VA any] []ActionVar1[A1, VA]

func CastDelegateVoidVar1

func CastDelegateVoidVar1[A1, VA, F ~func(A1, ...VA)](fs ...F) DelegateVoidVar1[A1, VA]

func (DelegateVoidVar1[A1, VA]) Call

func (d DelegateVoidVar1[A1, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, args ...VA) (panicErr error)

func (DelegateVoidVar1[A1, VA]) Combine

func (d DelegateVoidVar1[A1, VA]) Combine(f ...ActionVar1[A1, VA]) DelegateVoidVar1[A1, VA]

func (DelegateVoidVar1[A1, VA]) Exec

func (d DelegateVoidVar1[A1, VA]) Exec(interrupt Func1[error, bool], a1 A1, args ...VA)

func (DelegateVoidVar1[A1, VA]) Invoke

func (d DelegateVoidVar1[A1, VA]) Invoke(interrupt Func1[error, bool], a1 A1, args ...VA) (panicErr error)

func (DelegateVoidVar1[A1, VA]) ToAction

func (d DelegateVoidVar1[A1, VA]) ToAction(interrupt Func1[error, bool]) ActionVar1[A1, VA]

type DelegateVoidVar10

type DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any] []ActionVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA,
]

func CastDelegateVoidVar10

func CastDelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
)](fs ...F) DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

func (DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call

func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (panicErr error)

func (DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Combine

func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Combine(f ...ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

func (DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec

func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
)

func (DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke

func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (panicErr error)

func (DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) ToAction

func (d DelegateVoidVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) ToAction(interrupt Func1[error, bool]) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]

type DelegateVoidVar11

type DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any] []ActionVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA,
]

func CastDelegateVoidVar11

func CastDelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
)](fs ...F) DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

func (DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call

func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (panicErr error)

func (DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Combine

func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Combine(f ...ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

func (DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec

func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
)

func (DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke

func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (panicErr error)

func (DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) ToAction

func (d DelegateVoidVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) ToAction(interrupt Func1[error, bool]) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]

type DelegateVoidVar12

type DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any] []ActionVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA,
]

func CastDelegateVoidVar12

func CastDelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
)](fs ...F) DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

func (DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call

func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (panicErr error)

func (DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Combine

func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Combine(f ...ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

func (DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec

func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
)

func (DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke

func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (panicErr error)

func (DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) ToAction

func (d DelegateVoidVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) ToAction(interrupt Func1[error, bool]) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]

type DelegateVoidVar13

type DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any] []ActionVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA,
]

func CastDelegateVoidVar13

func CastDelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
)](fs ...F) DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

func (DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call

func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (panicErr error)

func (DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Combine

func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Combine(f ...ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

func (DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec

func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
)

func (DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke

func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (panicErr error)

func (DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) ToAction

func (d DelegateVoidVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) ToAction(interrupt Func1[error, bool]) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]

type DelegateVoidVar14

type DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any] []ActionVar14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA,
]

func CastDelegateVoidVar14

func CastDelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
)](fs ...F) DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

func (DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call

func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (panicErr error)

func (DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Combine

func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Combine(f ...ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

func (DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec

func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
)

func (DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke

func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (panicErr error)

func (DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) ToAction

func (d DelegateVoidVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) ToAction(interrupt Func1[error, bool]) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]

type DelegateVoidVar15

type DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any] []ActionVar15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA,
]

func CastDelegateVoidVar15

func CastDelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
)](fs ...F) DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

func (DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call

func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (panicErr error)

func (DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Combine

func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Combine(f ...ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

func (DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec

func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
)

func (DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke

func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (panicErr error)

func (DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) ToAction

func (d DelegateVoidVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) ToAction(interrupt Func1[error, bool]) ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]

type DelegateVoidVar16

type DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any] []ActionVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA,
]

func CastDelegateVoidVar16

func CastDelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
)](fs ...F) DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

func (DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call

func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (panicErr error)

func (DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Combine

func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Combine(f ...ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

func (DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec

func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
)

func (DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke

func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (panicErr error)

func (DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) ToAction

func (d DelegateVoidVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) ToAction(interrupt Func1[error, bool]) ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]

type DelegateVoidVar2

type DelegateVoidVar2[A1, A2, VA any] []ActionVar2[A1, A2, VA]

func CastDelegateVoidVar2

func CastDelegateVoidVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](fs ...F) DelegateVoidVar2[A1, A2, VA]

func (DelegateVoidVar2[A1, A2, VA]) Call

func (d DelegateVoidVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA) (panicErr error)

func (DelegateVoidVar2[A1, A2, VA]) Combine

func (d DelegateVoidVar2[A1, A2, VA]) Combine(f ...ActionVar2[A1, A2, VA]) DelegateVoidVar2[A1, A2, VA]

func (DelegateVoidVar2[A1, A2, VA]) Exec

func (d DelegateVoidVar2[A1, A2, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA)

func (DelegateVoidVar2[A1, A2, VA]) Invoke

func (d DelegateVoidVar2[A1, A2, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA) (panicErr error)

func (DelegateVoidVar2[A1, A2, VA]) ToAction

func (d DelegateVoidVar2[A1, A2, VA]) ToAction(interrupt Func1[error, bool]) ActionVar2[A1, A2, VA]

type DelegateVoidVar3

type DelegateVoidVar3[A1, A2, A3, VA any] []ActionVar3[A1, A2, A3, VA]

func CastDelegateVoidVar3

func CastDelegateVoidVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](fs ...F) DelegateVoidVar3[A1, A2, A3, VA]

func (DelegateVoidVar3[A1, A2, A3, VA]) Call

func (d DelegateVoidVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)

func (DelegateVoidVar3[A1, A2, A3, VA]) Combine

func (d DelegateVoidVar3[A1, A2, A3, VA]) Combine(f ...ActionVar3[A1, A2, A3, VA]) DelegateVoidVar3[A1, A2, A3, VA]

func (DelegateVoidVar3[A1, A2, A3, VA]) Exec

func (d DelegateVoidVar3[A1, A2, A3, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA)

func (DelegateVoidVar3[A1, A2, A3, VA]) Invoke

func (d DelegateVoidVar3[A1, A2, A3, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)

func (DelegateVoidVar3[A1, A2, A3, VA]) ToAction

func (d DelegateVoidVar3[A1, A2, A3, VA]) ToAction(interrupt Func1[error, bool]) ActionVar3[A1, A2, A3, VA]

type DelegateVoidVar4

type DelegateVoidVar4[A1, A2, A3, A4, VA any] []ActionVar4[A1, A2, A3, A4, VA]

func CastDelegateVoidVar4

func CastDelegateVoidVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](fs ...F) DelegateVoidVar4[A1, A2, A3, A4, VA]

func (DelegateVoidVar4[A1, A2, A3, A4, VA]) Call

func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (panicErr error)

func (DelegateVoidVar4[A1, A2, A3, A4, VA]) Combine

func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Combine(f ...ActionVar4[A1, A2, A3, A4, VA]) DelegateVoidVar4[A1, A2, A3, A4, VA]

func (DelegateVoidVar4[A1, A2, A3, A4, VA]) Exec

func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA)

func (DelegateVoidVar4[A1, A2, A3, A4, VA]) Invoke

func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (panicErr error)

func (DelegateVoidVar4[A1, A2, A3, A4, VA]) ToAction

func (d DelegateVoidVar4[A1, A2, A3, A4, VA]) ToAction(interrupt Func1[error, bool]) ActionVar4[A1, A2, A3, A4, VA]

type DelegateVoidVar5

type DelegateVoidVar5[A1, A2, A3, A4, A5, VA any] []ActionVar5[
	A1, A2, A3, A4, A5, VA,
]

func CastDelegateVoidVar5

func CastDelegateVoidVar5[A1, A2, A3, A4, A5, VA any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
)](fs ...F) DelegateVoidVar5[A1, A2, A3, A4, A5, VA]

func (DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Call

func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (panicErr error)

func (DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Combine

func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Combine(f ...ActionVar5[A1, A2, A3, A4, A5, VA]) DelegateVoidVar5[A1, A2, A3, A4, A5, VA]

func (DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Exec

func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
)

func (DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Invoke

func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (panicErr error)

func (DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) ToAction

func (d DelegateVoidVar5[A1, A2, A3, A4, A5, VA]) ToAction(interrupt Func1[error, bool]) ActionVar5[A1, A2, A3, A4, A5, VA]

type DelegateVoidVar6

type DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA any] []ActionVar6[
	A1, A2, A3, A4, A5, A6, VA,
]

func CastDelegateVoidVar6

func CastDelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
)](fs ...F) DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]

func (DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Call

func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (panicErr error)

func (DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Combine

func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Combine(f ...ActionVar6[A1, A2, A3, A4, A5, A6, VA]) DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]

func (DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Exec

func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
)

func (DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke

func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (panicErr error)

func (DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) ToAction

func (d DelegateVoidVar6[A1, A2, A3, A4, A5, A6, VA]) ToAction(interrupt Func1[error, bool]) ActionVar6[A1, A2, A3, A4, A5, A6, VA]

type DelegateVoidVar7

type DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA any] []ActionVar7[
	A1, A2, A3, A4, A5, A6, A7, VA,
]

func CastDelegateVoidVar7

func CastDelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
)](fs ...F) DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]

func (DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call

func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (panicErr error)

func (DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Combine

func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Combine(f ...ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]

func (DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec

func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
)

func (DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke

func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (panicErr error)

func (DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) ToAction

func (d DelegateVoidVar7[A1, A2, A3, A4, A5, A6, A7, VA]) ToAction(interrupt Func1[error, bool]) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]

type DelegateVoidVar8

type DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any] []ActionVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA,
]

func CastDelegateVoidVar8

func CastDelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
)](fs ...F) DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

func (DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call

func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (panicErr error)

func (DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Combine

func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Combine(f ...ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

func (DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec

func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
)

func (DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke

func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (panicErr error)

func (DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) ToAction

func (d DelegateVoidVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) ToAction(interrupt Func1[error, bool]) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]

type DelegateVoidVar9

type DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any] []ActionVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA,
]

func CastDelegateVoidVar9

func CastDelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
)](fs ...F) DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

func (DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call

func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(
	autoRecover bool, reportError chan error, interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (panicErr error)

func (DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Combine

func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Combine(f ...ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

func (DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec

func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
)

func (DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke

func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke(interrupt Func1[error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (panicErr error)

func (DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) ToAction

func (d DelegateVoidVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) ToAction(interrupt Func1[error, bool]) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

type Func0

type Func0[R any] func() R

func CastFunc0

func CastFunc0[R any, F ~func() R](f F) Func0[R]

func (Func0[R]) Call

func (f Func0[R]) Call(autoRecover bool, reportError chan error) (r R, panicErr error)

func (Func0[R]) Exec

func (f Func0[R]) Exec() (r R)

func (Func0[R]) Invoke

func (f Func0[R]) Invoke() (r R, panicErr error)

func (Func0[R]) ToDelegate

func (f Func0[R]) ToDelegate() Delegate0[R]

type Func1

type Func1[A1, R any] func(A1) R

func CastFunc1

func CastFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]

func (Func1[A1, R]) Call

func (f Func1[A1, R]) Call(autoRecover bool, reportError chan error, a1 A1) (r R, panicErr error)

func (Func1[A1, R]) Exec

func (f Func1[A1, R]) Exec(a1 A1) (r R)

func (Func1[A1, R]) Invoke

func (f Func1[A1, R]) Invoke(a1 A1) (r R, panicErr error)

func (Func1[A1, R]) ToDelegate

func (f Func1[A1, R]) ToDelegate() Delegate1[A1, R]

type Func10

type Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) R

func CastFunc10

func CastFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) R](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R)

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) ToDelegate

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) ToDelegate() Delegate10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

type Func11

type Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) R

func CastFunc11

func CastFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) R](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R)

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) ToDelegate

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) ToDelegate() Delegate11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

type Func12

type Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) R

func CastFunc12

func CastFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) R](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R)

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) ToDelegate

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) ToDelegate() Delegate12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

type Func13

type Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) R

func CastFunc13

func CastFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) R](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R)

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) ToDelegate

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) ToDelegate() Delegate13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

type Func14

type Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) R

func CastFunc14

func CastFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) R](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R)

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) ToDelegate

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) ToDelegate() Delegate14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

type Func15

type Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) R

func CastFunc15

func CastFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) R](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R)

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) ToDelegate

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) ToDelegate() Delegate15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

type Func16

type Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) R

func CastFunc16

func CastFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) R](f F) Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R)

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) ToDelegate

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) ToDelegate() Delegate16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

type Func2

type Func2[A1, A2, R any] func(A1, A2) R

func CastFunc2

func CastFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]

func (Func2[A1, A2, R]) Call

func (f Func2[A1, A2, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r R, panicErr error)

func (Func2[A1, A2, R]) Exec

func (f Func2[A1, A2, R]) Exec(a1 A1, a2 A2) (r R)

func (Func2[A1, A2, R]) Invoke

func (f Func2[A1, A2, R]) Invoke(a1 A1, a2 A2) (r R, panicErr error)

func (Func2[A1, A2, R]) ToDelegate

func (f Func2[A1, A2, R]) ToDelegate() Delegate2[A1, A2, R]

type Func3

type Func3[A1, A2, A3, R any] func(A1, A2, A3) R

func CastFunc3

func CastFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]

func (Func3[A1, A2, A3, R]) Call

func (f Func3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r R, panicErr error)

func (Func3[A1, A2, A3, R]) Exec

func (f Func3[A1, A2, A3, R]) Exec(a1 A1, a2 A2, a3 A3) (r R)

func (Func3[A1, A2, A3, R]) Invoke

func (f Func3[A1, A2, A3, R]) Invoke(a1 A1, a2 A2, a3 A3) (r R, panicErr error)

func (Func3[A1, A2, A3, R]) ToDelegate

func (f Func3[A1, A2, A3, R]) ToDelegate() Delegate3[A1, A2, A3, R]

type Func4

type Func4[A1, A2, A3, A4, R any] func(A1, A2, A3, A4) R

func CastFunc4

func CastFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]

func (Func4[A1, A2, A3, A4, R]) Call

func (f Func4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

func (Func4[A1, A2, A3, A4, R]) Exec

func (f Func4[A1, A2, A3, A4, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r R)

func (Func4[A1, A2, A3, A4, R]) Invoke

func (f Func4[A1, A2, A3, A4, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

func (Func4[A1, A2, A3, A4, R]) ToDelegate

func (f Func4[A1, A2, A3, A4, R]) ToDelegate() Delegate4[A1, A2, A3, A4, R]

type Func5

type Func5[A1, A2, A3, A4, A5, R any] func(
	A1, A2, A3, A4, A5,
) R

func CastFunc5

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 (Func5[A1, A2, A3, A4, A5, R]) Call

func (f Func5[A1, A2, A3, A4, A5, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

func (Func5[A1, A2, A3, A4, A5, R]) Exec

func (f Func5[A1, A2, A3, A4, A5, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R)

func (Func5[A1, A2, A3, A4, A5, R]) Invoke

func (f Func5[A1, A2, A3, A4, A5, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

func (Func5[A1, A2, A3, A4, A5, R]) ToDelegate

func (f Func5[A1, A2, A3, A4, A5, R]) ToDelegate() Delegate5[A1, A2, A3, A4, A5, R]

type Func6

type Func6[A1, A2, A3, A4, A5, A6, R any] func(
	A1, A2, A3, A4, A5, A6,
) R

func CastFunc6

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 (Func6[A1, A2, A3, A4, A5, A6, R]) Call

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

func (Func6[A1, A2, A3, A4, A5, A6, R]) Exec

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R)

func (Func6[A1, A2, A3, A4, A5, A6, R]) Invoke

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

func (Func6[A1, A2, A3, A4, A5, A6, R]) ToDelegate

func (f Func6[A1, A2, A3, A4, A5, A6, R]) ToDelegate() Delegate6[A1, A2, A3, A4, A5, A6, R]

type Func7

type Func7[A1, A2, A3, A4, A5, A6, A7, R any] func(
	A1, A2, A3, A4, A5, A6, A7,
) R

func CastFunc7

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 (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Call

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Exec

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R)

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) ToDelegate

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) ToDelegate() Delegate7[A1, A2, A3, A4, A5, A6, A7, R]

type Func8

type Func8[A1, A2, A3, A4, A5, A6, A7, A8, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) R

func CastFunc8

func CastFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) R](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R)

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToDelegate

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToDelegate() Delegate8[A1, A2, A3, A4, A5, A6, A7, A8, R]

type Func9

type Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) R

func CastFunc9

func CastFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) R](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R)

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToDelegate

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToDelegate() Delegate9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

type FuncPair0

type FuncPair0[R1, R2 any] func() (R1, R2)

func CastFuncPair0

func CastFuncPair0[R1, R2 any, F ~func() (R1, R2)](f F) FuncPair0[R1, R2]

func (FuncPair0[R1, R2]) Call

func (f FuncPair0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)

func (FuncPair0[R1, R2]) Exec

func (f FuncPair0[R1, R2]) Exec() (r1 R1, r2 R2)

func (FuncPair0[R1, R2]) Invoke

func (f FuncPair0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)

func (FuncPair0[R1, R2]) ToDelegate

func (f FuncPair0[R1, R2]) ToDelegate() DelegatePair0[R1, R2]

type FuncPair1

type FuncPair1[A1, R1, R2 any] func(A1) (R1, R2)

func CastFuncPair1

func CastFuncPair1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) FuncPair1[A1, R1, R2]

func (FuncPair1[A1, R1, R2]) Call

func (f FuncPair1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)

func (FuncPair1[A1, R1, R2]) Exec

func (f FuncPair1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)

func (FuncPair1[A1, R1, R2]) Invoke

func (f FuncPair1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)

func (FuncPair1[A1, R1, R2]) ToDelegate

func (f FuncPair1[A1, R1, R2]) ToDelegate() DelegatePair1[A1, R1, R2]

type FuncPair10

type FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)

func CastFuncPair10

func CastFuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)](f F) FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

func (FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call

func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec

func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2)

func (FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke

func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate

func (f FuncPair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate() DelegatePair10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

type FuncPair11

type FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)

func CastFuncPair11

func CastFuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)](f F) FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

func (FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call

func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec

func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2)

func (FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke

func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate

func (f FuncPair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate() DelegatePair11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

type FuncPair12

type FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)

func CastFuncPair12

func CastFuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)](f F) FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

func (FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call

func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec

func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2)

func (FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke

func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate

func (f FuncPair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate() DelegatePair12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

type FuncPair13

type FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)

func CastFuncPair13

func CastFuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)](f F) FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

func (FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call

func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec

func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2)

func (FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke

func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate

func (f FuncPair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate() DelegatePair13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

type FuncPair14

type FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)

func CastFuncPair14

func CastFuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)](f F) FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

func (FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call

func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec

func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2)

func (FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke

func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate

func (f FuncPair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate() DelegatePair14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

type FuncPair15

type FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)

func CastFuncPair15

func CastFuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)](f F) FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

func (FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call

func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec

func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2)

func (FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke

func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate

func (f FuncPair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate() DelegatePair15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

type FuncPair16

type FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)

func CastFuncPair16

func CastFuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)](f F) FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

func (FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call

func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec

func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2)

func (FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke

func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate

func (f FuncPair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate() DelegatePair16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

type FuncPair2

type FuncPair2[A1, A2, R1, R2 any] func(A1, A2) (R1, R2)

func CastFuncPair2

func CastFuncPair2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) FuncPair2[A1, A2, R1, R2]

func (FuncPair2[A1, A2, R1, R2]) Call

func (f FuncPair2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (FuncPair2[A1, A2, R1, R2]) Exec

func (f FuncPair2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)

func (FuncPair2[A1, A2, R1, R2]) Invoke

func (f FuncPair2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (FuncPair2[A1, A2, R1, R2]) ToDelegate

func (f FuncPair2[A1, A2, R1, R2]) ToDelegate() DelegatePair2[A1, A2, R1, R2]

type FuncPair3

type FuncPair3[A1, A2, A3, R1, R2 any] func(A1, A2, A3) (R1, R2)

func CastFuncPair3

func CastFuncPair3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) FuncPair3[A1, A2, A3, R1, R2]

func (FuncPair3[A1, A2, A3, R1, R2]) Call

func (f FuncPair3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (FuncPair3[A1, A2, A3, R1, R2]) Exec

func (f FuncPair3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

func (FuncPair3[A1, A2, A3, R1, R2]) Invoke

func (f FuncPair3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (FuncPair3[A1, A2, A3, R1, R2]) ToDelegate

func (f FuncPair3[A1, A2, A3, R1, R2]) ToDelegate() DelegatePair3[A1, A2, A3, R1, R2]

type FuncPair4

type FuncPair4[A1, A2, A3, A4, R1, R2 any] func(A1, A2, A3, A4) (R1, R2)

func CastFuncPair4

func CastFuncPair4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](f F) FuncPair4[A1, A2, A3, A4, R1, R2]

func (FuncPair4[A1, A2, A3, A4, R1, R2]) Call

func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (FuncPair4[A1, A2, A3, A4, R1, R2]) Exec

func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

func (FuncPair4[A1, A2, A3, A4, R1, R2]) Invoke

func (f FuncPair4[A1, A2, A3, A4, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (FuncPair4[A1, A2, A3, A4, R1, R2]) ToDelegate

func (f FuncPair4[A1, A2, A3, A4, R1, R2]) ToDelegate() DelegatePair4[A1, A2, A3, A4, R1, R2]

type FuncPair5

type FuncPair5[A1, A2, A3, A4, A5, R1, R2 any] func(
	A1, A2, A3, A4, A5,
) (R1, R2)

func CastFuncPair5

func CastFuncPair5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5,
) (R1, R2)](f F) FuncPair5[A1, A2, A3, A4, A5, R1, R2]

func (FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Call

func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Exec

func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2)

func (FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Invoke

func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate

func (f FuncPair5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate() DelegatePair5[A1, A2, A3, A4, A5, R1, R2]

type FuncPair6

type FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)

func CastFuncPair6

func CastFuncPair6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)](f F) FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]

func (FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call

func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec

func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2)

func (FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke

func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate

func (f FuncPair6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate() DelegatePair6[A1, A2, A3, A4, A5, A6, R1, R2]

type FuncPair7

type FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)

func CastFuncPair7

func CastFuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)](f F) FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call

func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec

func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2)

func (FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke

func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate

func (f FuncPair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate() DelegatePair7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

type FuncPair8

type FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)

func CastFuncPair8

func CastFuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)](f F) FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call

func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec

func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2)

func (FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke

func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate

func (f FuncPair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate() DelegatePair8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

type FuncPair9

type FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)

func CastFuncPair9

func CastFuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)](f F) FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call

func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec

func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2)

func (FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke

func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate

func (f FuncPair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate() DelegatePair9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type FuncPairVar0

type FuncPairVar0[VA, R1, R2 any] func(...VA) (R1, R2)

func CastFuncPairVar0

func CastFuncPairVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) FuncPairVar0[VA, R1, R2]

func (FuncPairVar0[VA, R1, R2]) Call

func (f FuncPairVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar0[VA, R1, R2]) Exec

func (f FuncPairVar0[VA, R1, R2]) Exec(args ...VA) (r1 R1, r2 R2)

func (FuncPairVar0[VA, R1, R2]) Invoke

func (f FuncPairVar0[VA, R1, R2]) Invoke(args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar0[VA, R1, R2]) ToDelegate

func (f FuncPairVar0[VA, R1, R2]) ToDelegate() DelegatePairVar0[VA, R1, R2]

type FuncPairVar1

type FuncPairVar1[A1, VA, R1, R2 any] func(A1, ...VA) (R1, R2)

func CastFuncPairVar1

func CastFuncPairVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) FuncPairVar1[A1, VA, R1, R2]

func (FuncPairVar1[A1, VA, R1, R2]) Call

func (f FuncPairVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar1[A1, VA, R1, R2]) Exec

func (f FuncPairVar1[A1, VA, R1, R2]) Exec(a1 A1, args ...VA) (r1 R1, r2 R2)

func (FuncPairVar1[A1, VA, R1, R2]) Invoke

func (f FuncPairVar1[A1, VA, R1, R2]) Invoke(a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar1[A1, VA, R1, R2]) ToDelegate

func (f FuncPairVar1[A1, VA, R1, R2]) ToDelegate() DelegatePairVar1[A1, VA, R1, R2]

type FuncPairVar10

type FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)

func CastFuncPairVar10

func CastFuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)](f F) FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call

func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec

func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke

func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate

func (f FuncPairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate() DelegatePairVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

type FuncPairVar11

type FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)

func CastFuncPairVar11

func CastFuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)](f F) FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call

func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec

func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke

func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate

func (f FuncPairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate() DelegatePairVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

type FuncPairVar12

type FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)

func CastFuncPairVar12

func CastFuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)](f F) FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call

func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec

func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke

func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate

func (f FuncPairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate() DelegatePairVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

type FuncPairVar13

type FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)

func CastFuncPairVar13

func CastFuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)](f F) FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call

func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec

func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke

func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate

func (f FuncPairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate() DelegatePairVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

type FuncPairVar14

type FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)

func CastFuncPairVar14

func CastFuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)](f F) FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call

func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec

func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke

func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate

func (f FuncPairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate() DelegatePairVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

type FuncPairVar15

type FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)

func CastFuncPairVar15

func CastFuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)](f F) FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call

func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec

func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke

func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate

func (f FuncPairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate() DelegatePairVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

type FuncPairVar16

type FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)

func CastFuncPairVar16

func CastFuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)](f F) FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call

func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec

func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke

func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate

func (f FuncPairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate() DelegatePairVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

type FuncPairVar2

type FuncPairVar2[A1, A2, VA, R1, R2 any] func(A1, A2, ...VA) (R1, R2)

func CastFuncPairVar2

func CastFuncPairVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) FuncPairVar2[A1, A2, VA, R1, R2]

func (FuncPairVar2[A1, A2, VA, R1, R2]) Call

func (f FuncPairVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar2[A1, A2, VA, R1, R2]) Exec

func (f FuncPairVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

func (FuncPairVar2[A1, A2, VA, R1, R2]) Invoke

func (f FuncPairVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar2[A1, A2, VA, R1, R2]) ToDelegate

func (f FuncPairVar2[A1, A2, VA, R1, R2]) ToDelegate() DelegatePairVar2[A1, A2, VA, R1, R2]

type FuncPairVar3

type FuncPairVar3[A1, A2, A3, VA, R1, R2 any] func(A1, A2, A3, ...VA) (R1, R2)

func CastFuncPairVar3

func CastFuncPairVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](f F) FuncPairVar3[A1, A2, A3, VA, R1, R2]

func (FuncPairVar3[A1, A2, A3, VA, R1, R2]) Call

func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar3[A1, A2, A3, VA, R1, R2]) Exec

func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

func (FuncPairVar3[A1, A2, A3, VA, R1, R2]) Invoke

func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar3[A1, A2, A3, VA, R1, R2]) ToDelegate

func (f FuncPairVar3[A1, A2, A3, VA, R1, R2]) ToDelegate() DelegatePairVar3[A1, A2, A3, VA, R1, R2]

type FuncPairVar4

type FuncPairVar4[A1, A2, A3, A4, VA, R1, R2 any] func(A1, A2, A3, A4, ...VA) (R1, R2)

func CastFuncPairVar4

func CastFuncPairVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](f F) FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]

func (FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Call

func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec

func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

func (FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke

func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate

func (f FuncPairVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate() DelegatePairVar4[A1, A2, A3, A4, VA, R1, R2]

type FuncPairVar5

type FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)

func CastFuncPairVar5

func CastFuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)](f F) FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call

func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec

func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke

func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate

func (f FuncPairVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate() DelegatePairVar5[A1, A2, A3, A4, A5, VA, R1, R2]

type FuncPairVar6

type FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)

func CastFuncPairVar6

func CastFuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)](f F) FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call

func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec

func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke

func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate

func (f FuncPairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate() DelegatePairVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

type FuncPairVar7

type FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)

func CastFuncPairVar7

func CastFuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)](f F) FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call

func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec

func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke

func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate

func (f FuncPairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate() DelegatePairVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

type FuncPairVar8

type FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)

func CastFuncPairVar8

func CastFuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)](f F) FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call

func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec

func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke

func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate

func (f FuncPairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate() DelegatePairVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

type FuncPairVar9

type FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)

func CastFuncPairVar9

func CastFuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)](f F) FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call

func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec

func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2)

func (FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke

func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate

func (f FuncPairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate() DelegatePairVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

type FuncVar0

type FuncVar0[VA, R any] func(...VA) R

func CastFuncVar0

func CastFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]

func (FuncVar0[VA, R]) Call

func (f FuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, args ...VA) (r R, panicErr error)

func (FuncVar0[VA, R]) Exec

func (f FuncVar0[VA, R]) Exec(args ...VA) (r R)

func (FuncVar0[VA, R]) Invoke

func (f FuncVar0[VA, R]) Invoke(args ...VA) (r R, panicErr error)

func (FuncVar0[VA, R]) ToDelegate

func (f FuncVar0[VA, R]) ToDelegate() DelegateVar0[VA, R]

type FuncVar1

type FuncVar1[A1, VA, R any] func(A1, ...VA) R

func CastFuncVar1

func CastFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]

func (FuncVar1[A1, VA, R]) Call

func (f FuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, args ...VA) (r R, panicErr error)

func (FuncVar1[A1, VA, R]) Exec

func (f FuncVar1[A1, VA, R]) Exec(a1 A1, args ...VA) (r R)

func (FuncVar1[A1, VA, R]) Invoke

func (f FuncVar1[A1, VA, R]) Invoke(a1 A1, args ...VA) (r R, panicErr error)

func (FuncVar1[A1, VA, R]) ToDelegate

func (f FuncVar1[A1, VA, R]) ToDelegate() DelegateVar1[A1, VA, R]

type FuncVar10

type FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) R

func CastFuncVar10

func CastFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) R](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r R, panicErr error)

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r R)

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r R, panicErr error)

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToDelegate

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToDelegate() DelegateVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

type FuncVar11

type FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) R

func CastFuncVar11

func CastFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) R](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r R, panicErr error)

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r R)

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r R, panicErr error)

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToDelegate

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToDelegate() DelegateVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

type FuncVar12

type FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) R

func CastFuncVar12

func CastFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) R](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r R, panicErr error)

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r R)

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r R, panicErr error)

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToDelegate

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToDelegate() DelegateVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

type FuncVar13

type FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) R

func CastFuncVar13

func CastFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) R](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r R, panicErr error)

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r R)

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r R, panicErr error)

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToDelegate

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToDelegate() DelegateVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

type FuncVar14

type FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) R

func CastFuncVar14

func CastFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) R](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r R, panicErr error)

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r R)

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r R, panicErr error)

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToDelegate

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToDelegate() DelegateVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

type FuncVar15

type FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) R

func CastFuncVar15

func CastFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) R](f F) FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r R, panicErr error)

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r R)

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r R, panicErr error)

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToDelegate

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToDelegate() DelegateVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

type FuncVar16

type FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R

func CastFuncVar16

func CastFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R](f F) FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r R, panicErr error)

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r R)

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r R, panicErr error)

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToDelegate

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToDelegate() DelegateVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

type FuncVar2

type FuncVar2[A1, A2, VA, R any] func(A1, A2, ...VA) R

func CastFuncVar2

func CastFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](f F) FuncVar2[A1, A2, VA, R]

func (FuncVar2[A1, A2, VA, R]) Call

func (f FuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, args ...VA) (r R, panicErr error)

func (FuncVar2[A1, A2, VA, R]) Exec

func (f FuncVar2[A1, A2, VA, R]) Exec(a1 A1, a2 A2, args ...VA) (r R)

func (FuncVar2[A1, A2, VA, R]) Invoke

func (f FuncVar2[A1, A2, VA, R]) Invoke(a1 A1, a2 A2, args ...VA) (r R, panicErr error)

func (FuncVar2[A1, A2, VA, R]) ToDelegate

func (f FuncVar2[A1, A2, VA, R]) ToDelegate() DelegateVar2[A1, A2, VA, R]

type FuncVar3

type FuncVar3[A1, A2, A3, VA, R any] func(A1, A2, A3, ...VA) R

func CastFuncVar3

func CastFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]

func (FuncVar3[A1, A2, A3, VA, R]) Call

func (f FuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

func (FuncVar3[A1, A2, A3, VA, R]) Exec

func (f FuncVar3[A1, A2, A3, VA, R]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r R)

func (FuncVar3[A1, A2, A3, VA, R]) Invoke

func (f FuncVar3[A1, A2, A3, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r R, panicErr error)

func (FuncVar3[A1, A2, A3, VA, R]) ToDelegate

func (f FuncVar3[A1, A2, A3, VA, R]) ToDelegate() DelegateVar3[A1, A2, A3, VA, R]

type FuncVar4

type FuncVar4[A1, A2, A3, A4, VA, R any] func(A1, A2, A3, A4, ...VA) R

func CastFuncVar4

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 (FuncVar4[A1, A2, A3, A4, VA, R]) Call

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

func (FuncVar4[A1, A2, A3, A4, VA, R]) Exec

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)

func (FuncVar4[A1, A2, A3, A4, VA, R]) Invoke

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)

func (FuncVar4[A1, A2, A3, A4, VA, R]) ToDelegate

func (f FuncVar4[A1, A2, A3, A4, VA, R]) ToDelegate() DelegateVar4[A1, A2, A3, A4, VA, R]

type FuncVar5

type FuncVar5[A1, A2, A3, A4, A5, VA, R any] func(
	A1, A2, A3, A4, A5, ...VA,
) R

func CastFuncVar5

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 (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Call

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r R, panicErr error)

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r R)

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r R, panicErr error)

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) ToDelegate

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) ToDelegate() DelegateVar5[A1, A2, A3, A4, A5, VA, R]

type FuncVar6

type FuncVar6[A1, A2, A3, A4, A5, A6, VA, R any] func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R

func CastFuncVar6

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 (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r R, panicErr error)

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r R)

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r R, panicErr error)

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToDelegate

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToDelegate() DelegateVar6[A1, A2, A3, A4, A5, A6, VA, R]

type FuncVar7

type FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R

func CastFuncVar7

func CastFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r R, panicErr error)

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r R)

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r R, panicErr error)

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToDelegate

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToDelegate() DelegateVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

type FuncVar8

type FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R

func CastFuncVar8

func CastFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r R, panicErr error)

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r R)

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r R, panicErr error)

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToDelegate

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToDelegate() DelegateVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

type FuncVar9

type FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R

func CastFuncVar9

func CastFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r R, panicErr error)

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r R)

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r R, panicErr error)

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToDelegate

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToDelegate() DelegateVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

type KV

type KV[K cmp.Ordered, V any] struct {
	K K
	V V
}

type List

type List[T any] struct {
	// contains filtered or unexported fields
}

List 链表

func NewList

func NewList[T any]() *List[T]

NewList 创建链表

func (*List[T]) Back

func (l *List[T]) Back() *Node[T]

Back 链表尾部

func (*List[T]) Front

func (l *List[T]) Front() *Node[T]

Front 链表头部

func (*List[T]) InsertAfter

func (l *List[T]) InsertAfter(value T, at *Node[T]) *Node[T]

InsertAfter 在链表指定位置后插入数据

func (*List[T]) InsertBefore

func (l *List[T]) InsertBefore(value T, at *Node[T]) *Node[T]

InsertBefore 在链表指定位置前插入数据

func (*List[T]) Len

func (l *List[T]) Len() int

Len 链表长度

func (*List[T]) MoveAfter

func (l *List[T]) MoveAfter(n, at *Node[T])

MoveAfter 移动节点至链表指定位置后

func (*List[T]) MoveBefore

func (l *List[T]) MoveBefore(n, at *Node[T])

MoveBefore 移动节点至链表指定位置前

func (*List[T]) MoveToBack

func (l *List[T]) MoveToBack(n *Node[T])

MoveToBack 移动节点至链表尾部

func (*List[T]) MoveToFront

func (l *List[T]) MoveToFront(n *Node[T])

MoveToFront 移动节点至链表头部

func (*List[T]) PushBack

func (l *List[T]) PushBack(value T) *Node[T]

PushBack 在链表尾部插入数据

func (*List[T]) PushBackList

func (l *List[T]) PushBackList(other *List[T])

PushBackList 在链表尾部插入其他链表，可以传入自身

func (*List[T]) PushFront

func (l *List[T]) PushFront(value T) *Node[T]

PushFront 在链表头部插入数据

func (*List[T]) PushFrontList

func (l *List[T]) PushFrontList(other *List[T])

PushFrontList 在链表头部插入其他链表，可以传入自身

func (*List[T]) Remove

func (l *List[T]) Remove(n *Node[T])

Remove 删除节点

func (*List[T]) ReversedTraversal

func (l *List[T]) ReversedTraversal(visitor func(n *Node[T]) bool)

ReversedTraversal 反向遍历节点

func (*List[T]) ReversedTraversalAt

func (l *List[T]) ReversedTraversalAt(visitor func(n *Node[T]) bool, at *Node[T])

ReversedTraversalAt 从指定位置开始反向遍历节点

func (*List[T]) Traversal

func (l *List[T]) Traversal(visitor func(n *Node[T]) bool)

Traversal 遍历节点

func (*List[T]) TraversalAt

func (l *List[T]) TraversalAt(visitor func(n *Node[T]) bool, at *Node[T])

TraversalAt 从指定位置开始遍历节点

func (*List[T]) Version

func (l *List[T]) Version() int64

Version 数据版本

type Node

type Node[T any] struct {
	V T
	// contains filtered or unexported fields
}

Node 链表节点

func (*Node[T]) Escape

func (n *Node[T]) Escape()

Escape 从链表中删除

func (*Node[T]) Escaped

func (n *Node[T]) Escaped() bool

Escaped 是否已从链表中删除

func (*Node[T]) Next

func (n *Node[T]) Next() *Node[T]

Next 下一个节点

func (*Node[T]) Prev

func (n *Node[T]) Prev() *Node[T]

Prev 前一个节点

func (*Node[T]) Version

func (n *Node[T]) Version() int64

Version 创建时的数据版本

type SliceMap

type SliceMap[K cmp.Ordered, V any] []KV[K, V]

func MakeSliceMap

func MakeSliceMap[K cmp.Ordered, V any](kvs ...KV[K, V]) SliceMap[K, V]

func MakeSliceMapFromGoMap

func MakeSliceMapFromGoMap[K cmp.Ordered, V any](m map[K]V) SliceMap[K, V]

func NewSliceMap

func NewSliceMap[K cmp.Ordered, V any](kvs ...KV[K, V]) *SliceMap[K, V]

func NewSliceMapFromGoMap

func NewSliceMapFromGoMap[K cmp.Ordered, V any](m map[K]V) *SliceMap[K, V]

func (*SliceMap[K, V]) Add

func (m *SliceMap[K, V]) Add(k K, v V)

func (SliceMap[K, V]) Clone

func (m SliceMap[K, V]) Clone() SliceMap[K, V]

func (*SliceMap[K, V]) Delete

func (m *SliceMap[K, V]) Delete(k K) bool

func (SliceMap[K, V]) Each

func (m SliceMap[K, V]) Each(fun Action2[K, V])

func (SliceMap[K, V]) Exist

func (m SliceMap[K, V]) Exist(k K) bool

func (SliceMap[K, V]) Get

func (m SliceMap[K, V]) Get(k K) (V, bool)

func (SliceMap[K, V]) Index

func (m SliceMap[K, V]) Index(k K) int

func (SliceMap[K, V]) Keys

func (m SliceMap[K, V]) Keys() []K

func (SliceMap[K, V]) Len

func (m SliceMap[K, V]) Len() int

func (SliceMap[K, V]) Range

func (m SliceMap[K, V]) Range(fun Func2[K, V, bool])

func (SliceMap[K, V]) ReversedEach

func (m SliceMap[K, V]) ReversedEach(fun Action2[K, V])

func (SliceMap[K, V]) ReversedRange

func (m SliceMap[K, V]) ReversedRange(fun Func2[K, V, bool])

func (SliceMap[K, V]) ToGoMap

func (m SliceMap[K, V]) ToGoMap() map[K]V

func (SliceMap[K, V]) ToUnorderedSliceMap

func (m SliceMap[K, V]) ToUnorderedSliceMap() UnorderedSliceMap[K, V]

func (*SliceMap[K, V]) TryAdd

func (m *SliceMap[K, V]) TryAdd(k K, v V) bool

func (SliceMap[K, V]) Value

func (m SliceMap[K, V]) Value(k K) V

func (SliceMap[K, V]) Values

func (m SliceMap[K, V]) Values() []V

type UnorderedKV

type UnorderedKV[K comparable, V any] struct {
	K K
	V V
}

type UnorderedSliceMap

type UnorderedSliceMap[K comparable, V any] []UnorderedKV[K, V]

func MakeUnorderedSliceMap

func MakeUnorderedSliceMap[K comparable, V any](kvs ...UnorderedKV[K, V]) UnorderedSliceMap[K, V]

func MakeUnorderedSliceMapFromGoMap

func MakeUnorderedSliceMapFromGoMap[K comparable, V any](m map[K]V) UnorderedSliceMap[K, V]

func NewUnorderedSliceMap

func NewUnorderedSliceMap[K comparable, V any](kvs ...UnorderedKV[K, V]) *UnorderedSliceMap[K, V]

func NewUnorderedSliceMapFromGoMap

func NewUnorderedSliceMapFromGoMap[K comparable, V any](m map[K]V) *UnorderedSliceMap[K, V]

func (*UnorderedSliceMap[K, V]) Add

func (m *UnorderedSliceMap[K, V]) Add(k K, v V)

func (UnorderedSliceMap[K, V]) Clone

func (m UnorderedSliceMap[K, V]) Clone() UnorderedSliceMap[K, V]

func (*UnorderedSliceMap[K, V]) Delete

func (m *UnorderedSliceMap[K, V]) Delete(k K) bool

func (UnorderedSliceMap[K, V]) Each

func (m UnorderedSliceMap[K, V]) Each(fun Action2[K, V])

func (UnorderedSliceMap[K, V]) Exist

func (m UnorderedSliceMap[K, V]) Exist(k K) bool

func (UnorderedSliceMap[K, V]) Get

func (m UnorderedSliceMap[K, V]) Get(k K) (V, bool)

func (UnorderedSliceMap[K, V]) Index

func (m UnorderedSliceMap[K, V]) Index(k K) int

func (UnorderedSliceMap[K, V]) Keys

func (m UnorderedSliceMap[K, V]) Keys() []K

func (UnorderedSliceMap[K, V]) Len

func (m UnorderedSliceMap[K, V]) Len() int

func (UnorderedSliceMap[K, V]) Range

func (m UnorderedSliceMap[K, V]) Range(fun Func2[K, V, bool])

func (UnorderedSliceMap[K, V]) ReversedEach

func (m UnorderedSliceMap[K, V]) ReversedEach(fun Action2[K, V])

func (UnorderedSliceMap[K, V]) ReversedRange

func (m UnorderedSliceMap[K, V]) ReversedRange(fun Func2[K, V, bool])

func (UnorderedSliceMap[K, V]) ToGoMap

func (m UnorderedSliceMap[K, V]) ToGoMap() map[K]V

func (*UnorderedSliceMap[K, V]) TryAdd

func (m *UnorderedSliceMap[K, V]) TryAdd(k K, v V) bool

func (UnorderedSliceMap[K, V]) Value

func (m UnorderedSliceMap[K, V]) Value(k K) V

func (UnorderedSliceMap[K, V]) Values

func (m UnorderedSliceMap[K, V]) Values() []V