generic

Documentation

Index

• func FuncError(err, panicErr error) error
• func PairFuncError[T any](r T, err, panicErr error) (T, error)
• type Action0
  • func MakeAction0[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() DelegateAction0
• type Action1
  • func MakeAction1[A1 any, F ~func(A1)](f F) Action1[A1]
  • func (f Action1[A1]) Call(autoRecover bool, reportError chan error, a1 A1) (panicErr error)
  • func (f Action1[A1]) Exec(a1 A1)
  • func (f Action1[A1]) Invoke(a1 A1) (panicErr error)
  • func (f Action1[A1]) ToDelegate() DelegateAction1[A1]
• type Action10
  • func MakeAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, ...](f F) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
  • func (f Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) 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() DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
• type Action11
  • func MakeAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, ...](f F) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
  • func (f Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) 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() DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
• type Action12
  • func MakeAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, ...](f F) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
  • func (f Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) 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() DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
• type Action13
  • func MakeAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, ...](f F) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
  • func (f Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) 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() DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
• type Action14
  • func MakeAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, ...](f F) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
  • func (f Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) 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() DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
• type Action15
  • func MakeAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, ...](f F) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]
  • func (f Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) 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 MakeAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any, ...](f F) ...
  • func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (panicErr error)
  • func (f Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) 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 MakeAction2[A1, A2 any, F ~func(A1, A2)](f F) Action2[A1, A2]
  • func (f Action2[A1, A2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (panicErr error)
  • func (f Action2[A1, A2]) Exec(a1 A1, a2 A2)
  • func (f Action2[A1, A2]) Invoke(a1 A1, a2 A2) (panicErr error)
  • func (f Action2[A1, A2]) ToDelegate() DelegateAction2[A1, A2]
• type Action3
  • func MakeAction3[A1, A2, A3 any, F ~func(A1, A2, A3)](f F) Action3[A1, A2, A3]
  • func (f Action3[A1, A2, A3]) 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() DelegateAction3[A1, A2, A3]
• type Action4
  • func MakeAction4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](f F) Action4[A1, A2, A3, A4]
  • func (f Action4[A1, A2, A3, A4]) 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() DelegateAction4[A1, A2, A3, A4]
• type Action5
  • func MakeAction5[A1, A2, A3, A4, A5 any, F ~func(A1, A2, A3, A4, A5)](f F) Action5[A1, A2, A3, A4, A5]
  • func (f Action5[A1, A2, A3, A4, A5]) 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() DelegateAction5[A1, A2, A3, A4, A5]
• type Action6
  • func MakeAction6[A1, A2, A3, A4, A5, A6 any, F ~func(A1, A2, A3, A4, A5, A6)](f F) Action6[A1, A2, A3, A4, A5, A6]
  • func (f Action6[A1, A2, A3, A4, A5, A6]) 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() DelegateAction6[A1, A2, A3, A4, A5, A6]
• type Action7
  • func MakeAction7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(A1, A2, A3, A4, A5, A6, A7)](f F) Action7[A1, A2, A3, A4, A5, A6, A7]
  • func (f Action7[A1, A2, A3, A4, A5, A6, A7]) 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() DelegateAction7[A1, A2, A3, A4, A5, A6, A7]
• type Action8
  • func MakeAction8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(A1, A2, A3, A4, A5, A6, A7, A8)](f F) Action8[A1, A2, A3, A4, A5, A6, A7, A8]
  • func (f Action8[A1, A2, A3, A4, A5, A6, A7, A8]) 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() DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]
• type Action9
  • func MakeAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, ...](f F) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
  • func (f Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) 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() DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
• type ActionVar0
  • func MakeActionVar0[VA any, F ~func(...VA)](f F) ActionVar0[VA]
  • func (f ActionVar0[VA]) 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() DelegateActionVar0[VA]
• type ActionVar1
  • func MakeActionVar1[A1, VA, F ~func(A1, ...VA)](f F) ActionVar1[A1, VA]
  • func (f ActionVar1[A1, VA]) Call(autoRecover bool, reportError chan error, a1 A1, 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() DelegateActionVar1[A1, VA]
• type ActionVar10
  • func MakeActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, ...](f F) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
  • func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) 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() DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
• type ActionVar11
  • func MakeActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, ...](f F) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
  • func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) 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() DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
• type ActionVar12
  • func MakeActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, ...](f F) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
  • func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) 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() DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
• type ActionVar13
  • func MakeActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, ...](f F) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
  • func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) 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() ...
• type ActionVar14
  • func MakeActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, ...](f F) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]
  • func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) 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 MakeActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any, ...](f F) ...
  • func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (panicErr error)
  • func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) 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 MakeActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any, ...](f F) ...
  • func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (panicErr error)
  • func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) 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 MakeActionVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](f F) ActionVar2[A1, A2, VA]
  • func (f ActionVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, 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() DelegateActionVar2[A1, A2, VA]
• type ActionVar3
  • func MakeActionVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](f F) ActionVar3[A1, A2, A3, VA]
  • func (f ActionVar3[A1, A2, A3, VA]) 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() DelegateActionVar3[A1, A2, A3, VA]
• type ActionVar4
  • func MakeActionVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](f F) ActionVar4[A1, A2, A3, A4, VA]
  • func (f ActionVar4[A1, A2, A3, A4, VA]) 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() DelegateActionVar4[A1, A2, A3, A4, VA]
• type ActionVar5
  • func MakeActionVar5[A1, A2, A3, A4, A5, VA any, F ~func(A1, A2, A3, A4, A5, ...VA)](f F) ActionVar5[A1, A2, A3, A4, A5, VA]
  • func (f ActionVar5[A1, A2, A3, A4, A5, VA]) 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() DelegateActionVar5[A1, A2, A3, A4, A5, VA]
• type ActionVar6
  • func MakeActionVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(A1, A2, A3, A4, A5, A6, ...VA)](f F) ActionVar6[A1, A2, A3, A4, A5, A6, VA]
  • func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) 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() DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]
• type ActionVar7
  • func MakeActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(A1, A2, A3, A4, A5, A6, A7, ...VA)](f F) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]
  • func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) 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() DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]
• type ActionVar8
  • func MakeActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, ...](f F) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
  • func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) 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() DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
• type ActionVar9
  • func MakeActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, ...](f F) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
  • func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) 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() DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
• type DelegateAction0
  • func MakeDelegateAction0[F ~func()](fs ...F) DelegateAction0
  • func (d DelegateAction0) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool]) (panicErr error)
  • func (d DelegateAction0) Exec(interrupt Func1[error, bool])
  • func (d DelegateAction0) Invoke(interrupt Func1[error, bool]) (panicErr error)
  • func (d DelegateAction0) ToAction(interrupt Func1[error, bool]) Action0
• type DelegateAction1
  • func MakeDelegateAction1[A1 any, F ~func(A1)](fs ...F) DelegateAction1[A1]
  • func (d DelegateAction1[A1]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1) (panicErr error)
  • func (d DelegateAction1[A1]) Exec(interrupt Func1[error, bool], a1 A1)
  • func (d DelegateAction1[A1]) Invoke(interrupt Func1[error, bool], a1 A1) (panicErr error)
  • func (d DelegateAction1[A1]) ToAction(interrupt Func1[error, bool]) Action1[A1]
• type DelegateAction10
  • func MakeDelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 any, ...](fs ...F) DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
  • func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) ToAction(interrupt Func1[error, bool]) Action10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]
• type DelegateAction11
  • func MakeDelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 any, ...](fs ...F) DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
  • func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]) ToAction(interrupt Func1[error, bool]) Action11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]
• type DelegateAction12
  • func MakeDelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 any, ...](fs ...F) DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
  • func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]) ToAction(interrupt Func1[error, bool]) Action12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]
• type DelegateAction13
  • func MakeDelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 any, ...](fs ...F) DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
  • func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]) ToAction(interrupt Func1[error, bool]) Action13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]
• type DelegateAction14
  • func MakeDelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 any, ...](fs ...F) DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
  • func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]) ToAction(interrupt Func1[error, bool]) Action14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]
• type DelegateAction15
  • func MakeDelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15 any, ...](fs ...F) ...
  • func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) ToAction(interrupt Func1[error, bool]) Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]
• type DelegateAction16
  • func MakeDelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16 any, ...](fs ...F) ...
  • func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) ToAction(interrupt Func1[error, bool]) ...
• type DelegateAction2
  • func MakeDelegateAction2[A1, A2 any, F ~func(A1, A2)](fs ...F) DelegateAction2[A1, A2]
  • func (d DelegateAction2[A1, A2]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction2[A1, A2]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2)
  • func (d DelegateAction2[A1, A2]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2) (panicErr error)
  • func (d DelegateAction2[A1, A2]) ToAction(interrupt Func1[error, bool]) Action2[A1, A2]
• type DelegateAction3
  • func MakeDelegateAction3[A1, A2, A3 any, F ~func(A1, A2, A3)](fs ...F) DelegateAction3[A1, A2, A3]
  • func (d DelegateAction3[A1, A2, A3]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction3[A1, A2, A3]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3)
  • func (d DelegateAction3[A1, A2, A3]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3) (panicErr error)
  • func (d DelegateAction3[A1, A2, A3]) ToAction(interrupt Func1[error, bool]) Action3[A1, A2, A3]
• type DelegateAction4
  • func MakeDelegateAction4[A1, A2, A3, A4 any, F ~func(A1, A2, A3, A4)](fs ...F) DelegateAction4[A1, A2, A3, A4]
  • func (d DelegateAction4[A1, A2, A3, A4]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction4[A1, A2, A3, A4]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4)
  • func (d DelegateAction4[A1, A2, A3, A4]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (panicErr error)
  • func (d DelegateAction4[A1, A2, A3, A4]) ToAction(interrupt Func1[error, bool]) Action4[A1, A2, A3, A4]
• type DelegateAction5
  • func MakeDelegateAction5[A1, A2, A3, A4, A5 any, F ~func(A1, A2, A3, A4, A5)](fs ...F) DelegateAction5[A1, A2, A3, A4, A5]
  • func (d DelegateAction5[A1, A2, A3, A4, A5]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction5[A1, A2, A3, A4, A5]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5)
  • func (d DelegateAction5[A1, A2, A3, A4, A5]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (panicErr error)
  • func (d DelegateAction5[A1, A2, A3, A4, A5]) ToAction(interrupt Func1[error, bool]) Action5[A1, A2, A3, A4, A5]
• type DelegateAction6
  • func MakeDelegateAction6[A1, A2, A3, A4, A5, A6 any, F ~func(A1, A2, A3, A4, A5, A6)](fs ...F) DelegateAction6[A1, A2, A3, A4, A5, A6]
  • func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6)
  • func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (panicErr error)
  • func (d DelegateAction6[A1, A2, A3, A4, A5, A6]) ToAction(interrupt Func1[error, bool]) Action6[A1, A2, A3, A4, A5, A6]
• type DelegateAction7
  • func MakeDelegateAction7[A1, A2, A3, A4, A5, A6, A7 any, F ~func(A1, A2, A3, A4, A5, A6, A7)](fs ...F) DelegateAction7[A1, A2, A3, A4, A5, A6, A7]
  • func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7)
  • func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (panicErr error)
  • func (d DelegateAction7[A1, A2, A3, A4, A5, A6, A7]) ToAction(interrupt Func1[error, bool]) Action7[A1, A2, A3, A4, A5, A6, A7]
• type DelegateAction8
  • func MakeDelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8 any, F ~func(A1, A2, A3, A4, A5, A6, A7, A8)](fs ...F) DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]
  • func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction8[A1, A2, A3, A4, A5, A6, A7, A8]) ToAction(interrupt Func1[error, bool]) Action8[A1, A2, A3, A4, A5, A6, A7, A8]
• type DelegateAction9
  • func MakeDelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9 any, ...](fs ...F) DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
  • func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateAction9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) ToAction(interrupt Func1[error, bool]) Action9[A1, A2, A3, A4, A5, A6, A7, A8, A9]
• type DelegateActionVar0
  • func MakeDelegateActionVar0[VA any, F ~func(...VA)](fs ...F) DelegateActionVar0[VA]
  • func (d DelegateActionVar0[VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], ...) (panicErr error)
  • func (d DelegateActionVar0[VA]) Exec(interrupt Func1[error, bool], args ...VA)
  • func (d DelegateActionVar0[VA]) Invoke(interrupt Func1[error, bool], args ...VA) (panicErr error)
  • func (d DelegateActionVar0[VA]) ToAction(interrupt Func1[error, bool]) ActionVar0[VA]
• type DelegateActionVar1
  • func MakeDelegateActionVar1[A1, VA, F ~func(A1, ...VA)](fs ...F) DelegateActionVar1[A1, VA]
  • func (d DelegateActionVar1[A1, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar1[A1, VA]) Exec(interrupt Func1[error, bool], a1 A1, args ...VA)
  • func (d DelegateActionVar1[A1, VA]) Invoke(interrupt Func1[error, bool], a1 A1, args ...VA) (panicErr error)
  • func (d DelegateActionVar1[A1, VA]) ToAction(interrupt Func1[error, bool]) ActionVar1[A1, VA]
• type DelegateActionVar10
  • func MakeDelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA any, ...](fs ...F) DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
  • func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) ToAction(interrupt Func1[error, bool]) ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]
• type DelegateActionVar11
  • func MakeDelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA any, ...](fs ...F) DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
  • func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) ToAction(interrupt Func1[error, bool]) ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]
• type DelegateActionVar12
  • func MakeDelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA any, ...](fs ...F) DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
  • func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) ToAction(interrupt Func1[error, bool]) ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]
• type DelegateActionVar13
  • func MakeDelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA any, ...](fs ...F) ...
  • func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) ToAction(interrupt Func1[error, bool]) ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]
• type DelegateActionVar14
  • func MakeDelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA any, ...](fs ...F) ...
  • func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) ToAction(interrupt Func1[error, bool]) ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]
• type DelegateActionVar15
  • func MakeDelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA any, ...](fs ...F) ...
  • func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) ToAction(interrupt Func1[error, bool]) ...
• type DelegateActionVar16
  • func MakeDelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA any, ...](fs ...F) ...
  • func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) ToAction(interrupt Func1[error, bool]) ...
• type DelegateActionVar2
  • func MakeDelegateActionVar2[A1, A2, VA any, F ~func(A1, A2, ...VA)](fs ...F) DelegateActionVar2[A1, A2, VA]
  • func (d DelegateActionVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar2[A1, A2, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA)
  • func (d DelegateActionVar2[A1, A2, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, args ...VA) (panicErr error)
  • func (d DelegateActionVar2[A1, A2, VA]) ToAction(interrupt Func1[error, bool]) ActionVar2[A1, A2, VA]
• type DelegateActionVar3
  • func MakeDelegateActionVar3[A1, A2, A3, VA any, F ~func(A1, A2, A3, ...VA)](fs ...F) DelegateActionVar3[A1, A2, A3, VA]
  • func (d DelegateActionVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar3[A1, A2, A3, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA)
  • func (d DelegateActionVar3[A1, A2, A3, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (panicErr error)
  • func (d DelegateActionVar3[A1, A2, A3, VA]) ToAction(interrupt Func1[error, bool]) ActionVar3[A1, A2, A3, VA]
• type DelegateActionVar4
  • func MakeDelegateActionVar4[A1, A2, A3, A4, VA any, F ~func(A1, A2, A3, A4, ...VA)](fs ...F) DelegateActionVar4[A1, A2, A3, A4, VA]
  • func (d DelegateActionVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar4[A1, A2, A3, A4, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA)
  • func (d DelegateActionVar4[A1, A2, A3, A4, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (panicErr error)
  • func (d DelegateActionVar4[A1, A2, A3, A4, VA]) ToAction(interrupt Func1[error, bool]) ActionVar4[A1, A2, A3, A4, VA]
• type DelegateActionVar5
  • func MakeDelegateActionVar5[A1, A2, A3, A4, A5, VA any, F ~func(A1, A2, A3, A4, A5, ...VA)](fs ...F) DelegateActionVar5[A1, A2, A3, A4, A5, VA]
  • func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA)
  • func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (panicErr error)
  • func (d DelegateActionVar5[A1, A2, A3, A4, A5, VA]) ToAction(interrupt Func1[error, bool]) ActionVar5[A1, A2, A3, A4, A5, VA]
• type DelegateActionVar6
  • func MakeDelegateActionVar6[A1, A2, A3, A4, A5, A6, VA any, F ~func(A1, A2, A3, A4, A5, A6, ...VA)](fs ...F) DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]
  • func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...)
  • func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (panicErr error)
  • func (d DelegateActionVar6[A1, A2, A3, A4, A5, A6, VA]) ToAction(interrupt Func1[error, bool]) ActionVar6[A1, A2, A3, A4, A5, A6, VA]
• type DelegateActionVar7
  • func MakeDelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA any, F ~func(A1, A2, A3, A4, A5, A6, A7, ...VA)](fs ...F) DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]
  • func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) ToAction(interrupt Func1[error, bool]) ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]
• type DelegateActionVar8
  • func MakeDelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA any, ...](fs ...F) DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
  • func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) ToAction(interrupt Func1[error, bool]) ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]
• type DelegateActionVar9
  • func MakeDelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA any, ...](fs ...F) DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
  • func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(autoRecover bool, reportError chan error, interrupt Func1[error, bool], a1 A1, ...) (panicErr error)
  • func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Exec(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...)
  • func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Invoke(interrupt Func1[error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, ...) (panicErr error)
  • func (d DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) ToAction(interrupt Func1[error, bool]) ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]
• type DelegateFunc0
  • func MakeDelegateFunc0[R any, F ~func() R](fs ...F) DelegateFunc0[R]
  • func (d DelegateFunc0[R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool]) (r R, panicErr error)
  • func (d DelegateFunc0[R]) Exec(interrupt Func2[R, error, bool]) (r R)
  • func (d DelegateFunc0[R]) Invoke(interrupt Func2[R, error, bool]) (r R, panicErr error)
  • func (d DelegateFunc0[R]) ToFunc(interrupt Func2[R, error, bool]) Func0[R]
• type DelegateFunc1
  • func MakeDelegateFunc1[A1, R any, F ~func(A1) R](fs ...F) DelegateFunc1[A1, R]
  • func (d DelegateFunc1[A1, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc1[A1, R]) Exec(interrupt Func2[R, error, bool], a1 A1) (r R)
  • func (d DelegateFunc1[A1, R]) Invoke(interrupt Func2[R, error, bool], a1 A1) (r R, panicErr error)
  • func (d DelegateFunc1[A1, R]) ToFunc(interrupt Func2[R, error, bool]) Func1[A1, R]
• type DelegateFunc10
  • func MakeDelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](fs ...F) DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
  • func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) ToFunc(interrupt Func2[R, error, bool]) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
• type DelegateFunc11
  • func MakeDelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](fs ...F) DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
  • func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) ToFunc(interrupt Func2[R, error, bool]) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
• type DelegateFunc12
  • func MakeDelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](fs ...F) DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
  • func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) ToFunc(interrupt Func2[R, error, bool]) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
• type DelegateFunc13
  • func MakeDelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, ...](fs ...F) DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
  • func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) ToFunc(interrupt Func2[R, error, bool]) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
• type DelegateFunc14
  • func MakeDelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, ...](fs ...F) DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
  • func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) ToFunc(interrupt Func2[R, error, bool]) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
• type DelegateFunc15
  • func MakeDelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, ...](fs ...F) ...
  • func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) ToFunc(interrupt Func2[R, error, bool]) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]
• type DelegateFunc16
  • func MakeDelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, ...](fs ...F) ...
  • func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) ToFunc(interrupt Func2[R, error, bool]) ...
• type DelegateFunc2
  • func MakeDelegateFunc2[A1, A2, R any, F ~func(A1, A2) R](fs ...F) DelegateFunc2[A1, A2, R]
  • func (d DelegateFunc2[A1, A2, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc2[A1, A2, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R)
  • func (d DelegateFunc2[A1, A2, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2) (r R, panicErr error)
  • func (d DelegateFunc2[A1, A2, R]) ToFunc(interrupt Func2[R, error, bool]) Func2[A1, A2, R]
• type DelegateFunc3
  • func MakeDelegateFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](fs ...F) DelegateFunc3[A1, A2, A3, R]
  • func (d DelegateFunc3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc3[A1, A2, A3, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R)
  • func (d DelegateFunc3[A1, A2, A3, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3) (r R, panicErr error)
  • func (d DelegateFunc3[A1, A2, A3, R]) ToFunc(interrupt Func2[R, error, bool]) Func3[A1, A2, A3, R]
• type DelegateFunc4
  • func MakeDelegateFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](fs ...F) DelegateFunc4[A1, A2, A3, A4, R]
  • func (d DelegateFunc4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc4[A1, A2, A3, A4, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R)
  • func (d DelegateFunc4[A1, A2, A3, A4, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)
  • func (d DelegateFunc4[A1, A2, A3, A4, R]) ToFunc(interrupt Func2[R, error, bool]) Func4[A1, A2, A3, A4, R]
• type DelegateFunc5
  • func MakeDelegateFunc5[A1, A2, A3, A4, A5, R any, F ~func(A1, A2, A3, A4, A5) R](fs ...F) DelegateFunc5[A1, A2, A3, A4, A5, R]
  • func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R)
  • func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r R, panicErr error)
  • func (d DelegateFunc5[A1, A2, A3, A4, A5, R]) ToFunc(interrupt Func2[R, error, bool]) Func5[A1, A2, A3, A4, A5, R]
• type DelegateFunc6
  • func MakeDelegateFunc6[A1, A2, A3, A4, A5, A6, R any, F ~func(A1, A2, A3, A4, A5, A6) R](fs ...F) DelegateFunc6[A1, A2, A3, A4, A5, A6, R]
  • func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r R)
  • func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r R, panicErr error)
  • func (d DelegateFunc6[A1, A2, A3, A4, A5, A6, R]) ToFunc(interrupt Func2[R, error, bool]) Func6[A1, A2, A3, A4, A5, A6, R]
• type DelegateFunc7
  • func MakeDelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(A1, A2, A3, A4, A5, A6, A7) R](fs ...F) DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]
  • func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]) ToFunc(interrupt Func2[R, error, bool]) Func7[A1, A2, A3, A4, A5, A6, A7, R]
• type DelegateFunc8
  • func MakeDelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](fs ...F) DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]
  • func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]) ToFunc(interrupt Func2[R, error, bool]) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]
• type DelegateFunc9
  • func MakeDelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](fs ...F) DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
  • func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) ToFunc(interrupt Func2[R, error, bool]) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
• type DelegateFuncVar0
  • func MakeDelegateFuncVar0[VA, R any, F ~func(...VA) R](fs ...F) DelegateFuncVar0[VA, R]
  • func (d DelegateFuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar0[VA, R]) Exec(interrupt Func2[R, error, bool], args ...VA) (r R)
  • func (d DelegateFuncVar0[VA, R]) Invoke(interrupt Func2[R, error, bool], args ...VA) (r R, panicErr error)
  • func (d DelegateFuncVar0[VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar0[VA, R]
• type DelegateFuncVar1
  • func MakeDelegateFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](fs ...F) DelegateFuncVar1[A1, VA, R]
  • func (d DelegateFuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar1[A1, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R)
  • func (d DelegateFuncVar1[A1, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, args ...VA) (r R, panicErr error)
  • func (d DelegateFuncVar1[A1, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar1[A1, VA, R]
• type DelegateFuncVar10
  • func MakeDelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](fs ...F) DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
  • func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
• type DelegateFuncVar11
  • func MakeDelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](fs ...F) DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
  • func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
• type DelegateFuncVar12
  • func MakeDelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](fs ...F) DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
  • func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
• type DelegateFuncVar13
  • func MakeDelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](fs ...F) ...
  • func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
• type DelegateFuncVar14
  • func MakeDelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, ...](fs ...F) ...
  • func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]
• type DelegateFuncVar15
  • func MakeDelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, ...](fs ...F) ...
  • func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...
• type DelegateFuncVar16
  • func MakeDelegateFuncVar16[...](fs ...F) ...
  • func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) ToFunc(interrupt Func2[R, error, bool]) ...
• type DelegateFuncVar2
  • func MakeDelegateFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateFuncVar2[A1, A2, VA, R]
  • func (d DelegateFuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar2[A1, A2, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R)
  • func (d DelegateFuncVar2[A1, A2, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, args ...VA) (r R, panicErr error)
  • func (d DelegateFuncVar2[A1, A2, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar2[A1, A2, VA, R]
• type DelegateFuncVar3
  • func MakeDelegateFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateFuncVar3[A1, A2, A3, VA, R]
  • func (d DelegateFuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar3[A1, A2, A3, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r R)
  • func (d DelegateFuncVar3[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 DelegateFuncVar3[A1, A2, A3, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar3[A1, A2, A3, VA, R]
• type DelegateFuncVar4
  • func MakeDelegateFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](fs ...F) DelegateFuncVar4[A1, A2, A3, A4, VA, R]
  • func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R)
  • func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r R, panicErr error)
  • func (d DelegateFuncVar4[A1, A2, A3, A4, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar4[A1, A2, A3, A4, VA, R]
• type DelegateFuncVar5
  • func MakeDelegateFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(A1, A2, A3, A4, A5, ...VA) R](fs ...F) DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]
  • func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R)
  • func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r R, panicErr error)
  • func (d DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar5[A1, A2, A3, A4, A5, VA, R]
• type DelegateFuncVar6
  • func MakeDelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(A1, A2, A3, A4, A5, A6, ...VA) R](fs ...F) DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]
  • func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]
• type DelegateFuncVar7
  • func MakeDelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](fs ...F) DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
  • func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
• type DelegateFuncVar8
  • func MakeDelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](fs ...F) DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
  • func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
• type DelegateFuncVar9
  • func MakeDelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](fs ...F) DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
  • func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(autoRecover bool, reportError chan error, interrupt Func2[R, error, bool], ...) (r R, panicErr error)
  • func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Exec(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R)
  • func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Invoke(interrupt Func2[R, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r R, panicErr error)
  • func (d DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) ToFunc(interrupt Func2[R, error, bool]) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
• type DelegatePairFunc0
  • func MakeDelegatePairFunc0[R1, R2 any, F ~func() (R1, R2)](fs ...F) DelegatePairFunc0[R1, R2]
  • func (d DelegatePairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc0[R1, R2]) Exec(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2)
  • func (d DelegatePairFunc0[R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool]) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc0[R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc0[R1, R2]
• type DelegatePairFunc1
  • func MakeDelegatePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](fs ...F) DelegatePairFunc1[A1, R1, R2]
  • func (d DelegatePairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc1[A1, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2)
  • func (d DelegatePairFunc1[A1, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc1[A1, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc1[A1, R1, R2]
• type DelegatePairFunc10
  • func MakeDelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](fs ...F) DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
  • func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
• type DelegatePairFunc11
  • func MakeDelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](fs ...F) DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
  • func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
• type DelegatePairFunc12
  • func MakeDelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](fs ...F) DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
  • func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
• type DelegatePairFunc13
  • func MakeDelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
• type DelegatePairFunc14
  • func MakeDelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFunc15
  • func MakeDelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFunc16
  • func MakeDelegatePairFunc16[...](fs ...F) ...
  • func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFunc2
  • func MakeDelegatePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](fs ...F) DelegatePairFunc2[A1, A2, R1, R2]
  • func (d DelegatePairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc2[A1, A2, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2)
  • func (d DelegatePairFunc2[A1, A2, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc2[A1, A2, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc2[A1, A2, R1, R2]
• type DelegatePairFunc3
  • func MakeDelegatePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](fs ...F) DelegatePairFunc3[A1, A2, A3, R1, R2]
  • func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)
  • func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc3[A1, A2, A3, R1, R2]
• type DelegatePairFunc4
  • func MakeDelegatePairFunc4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](fs ...F) DelegatePairFunc4[A1, A2, A3, A4, R1, R2]
  • func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)
  • func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc4[A1, A2, A3, A4, R1, R2]
• type DelegatePairFunc5
  • func MakeDelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(A1, A2, A3, A4, A5) (R1, R2)](fs ...F) DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]
  • func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)
  • func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc5[A1, A2, A3, A4, A5, R1, R2]
• type DelegatePairFunc6
  • func MakeDelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(A1, A2, A3, A4, A5, A6) (R1, R2)](fs ...F) DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]
  • func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2)
  • func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]
• type DelegatePairFunc7
  • func MakeDelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](fs ...F) DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
  • func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
• type DelegatePairFunc8
  • func MakeDelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](fs ...F) DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
  • func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
• type DelegatePairFunc9
  • func MakeDelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](fs ...F) DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
  • func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
• type DelegatePairFuncVar0
  • func MakeDelegatePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairFuncVar0[VA, R1, R2]
  • func (d DelegatePairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar0[VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar0[VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar0[VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar0[VA, R1, R2]
• type DelegatePairFuncVar1
  • func MakeDelegatePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar1[A1, VA, R1, R2]
  • func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar1[A1, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar1[A1, VA, R1, R2]
• type DelegatePairFuncVar10
  • func MakeDelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
  • func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
• type DelegatePairFuncVar11
  • func MakeDelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
• type DelegatePairFuncVar12
  • func MakeDelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]
• type DelegatePairFuncVar13
  • func MakeDelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFuncVar14
  • func MakeDelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](fs ...F) ...
  • func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFuncVar15
  • func MakeDelegatePairFuncVar15[...](fs ...F) ...
  • func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFuncVar16
  • func MakeDelegatePairFuncVar16[...](fs ...F) ...
  • func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) ...
• type DelegatePairFuncVar2
  • func MakeDelegatePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar2[A1, A2, VA, R1, R2]
  • func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar2[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 DelegatePairFuncVar2[A1, A2, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar2[A1, A2, VA, R1, R2]
• type DelegatePairFuncVar3
  • func MakeDelegatePairFuncVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]
  • func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar3[A1, A2, A3, VA, R1, R2]
• type DelegatePairFuncVar4
  • func MakeDelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]
  • func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]
• type DelegatePairFuncVar5
  • func MakeDelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]
  • func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]
• type DelegatePairFuncVar6
  • func MakeDelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
  • func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
• type DelegatePairFuncVar7
  • func MakeDelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
  • func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
• type DelegatePairFuncVar8
  • func MakeDelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
  • func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
• type DelegatePairFuncVar9
  • func MakeDelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](fs ...F) DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
  • func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2)
  • func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, ...) (r1 R1, r2 R2, panicErr error)
  • func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
• type Func0
  • func MakeFunc0[R any, F ~func() R](f F) Func0[R]
  • func (f Func0[R]) Call(autoRecover bool, reportError chan error) (r R, panicErr error)
  • func (f Func0[R]) Exec() (r R)
  • func (f Func0[R]) Invoke() (r R, panicErr error)
  • func (f Func0[R]) ToDelegate() DelegateFunc0[R]
• type Func1
  • func MakeFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]
  • func (f Func1[A1, R]) Call(autoRecover bool, reportError chan error, a1 A1) (r R, panicErr error)
  • func (f Func1[A1, R]) Exec(a1 A1) (r R)
  • func (f Func1[A1, R]) Invoke(a1 A1) (r R, panicErr error)
  • func (f Func1[A1, R]) ToDelegate() DelegateFunc1[A1, R]
• type Func10
  • func MakeFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, ...](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
  • func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) 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() DelegateFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]
• type Func11
  • func MakeFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, ...](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
  • func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) 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() DelegateFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]
• type Func12
  • func MakeFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, ...](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
  • func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) 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() DelegateFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]
• type Func13
  • func MakeFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, ...](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
  • func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) 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() DelegateFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]
• type Func14
  • func MakeFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, ...](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
  • func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) 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() DelegateFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]
• type Func15
  • func MakeFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, ...](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]
  • func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) 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 MakeFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, ...](f F) ...
  • func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r R, panicErr error)
  • func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) 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 MakeFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]
  • func (f Func2[A1, A2, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r R, panicErr error)
  • func (f Func2[A1, A2, R]) 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() DelegateFunc2[A1, A2, R]
• type Func3
  • func MakeFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]
  • func (f Func3[A1, A2, A3, R]) 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() DelegateFunc3[A1, A2, A3, R]
• type Func4
  • func MakeFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]
  • func (f Func4[A1, A2, A3, A4, R]) 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() DelegateFunc4[A1, A2, A3, A4, R]
• type Func5
  • func MakeFunc5[A1, A2, A3, A4, A5, R any, F ~func(A1, A2, A3, A4, A5) R](f F) Func5[A1, A2, A3, A4, A5, R]
  • func (f Func5[A1, A2, A3, A4, A5, R]) 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() DelegateFunc5[A1, A2, A3, A4, A5, R]
• type Func6
  • func MakeFunc6[A1, A2, A3, A4, A5, A6, R any, F ~func(A1, A2, A3, A4, A5, A6) R](f F) Func6[A1, A2, A3, A4, A5, A6, R]
  • func (f Func6[A1, A2, A3, A4, A5, A6, R]) 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() DelegateFunc6[A1, A2, A3, A4, A5, A6, R]
• type Func7
  • func MakeFunc7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(A1, A2, A3, A4, A5, A6, A7) R](f F) Func7[A1, A2, A3, A4, A5, A6, A7, R]
  • func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) 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() DelegateFunc7[A1, A2, A3, A4, A5, A6, A7, R]
• type Func8
  • func MakeFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, ...](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]
  • func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) 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() DelegateFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R]
• type Func9
  • func MakeFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, ...](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
  • func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) 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() DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]
• type FuncVar0
  • func MakeFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]
  • func (f FuncVar0[VA, R]) 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() DelegateFuncVar0[VA, R]
• type FuncVar1
  • func MakeFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]
  • func (f FuncVar1[A1, VA, R]) 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() DelegateFuncVar1[A1, VA, R]
• type FuncVar10
  • func MakeFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, ...](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
  • func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) 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() DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]
• type FuncVar11
  • func MakeFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, ...](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
  • func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) 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() DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]
• type FuncVar12
  • func MakeFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, ...](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
  • func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) 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() DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]
• type FuncVar13
  • func MakeFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, ...](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]
  • func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) 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() ...
• type FuncVar14
  • func MakeFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, ...](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]
  • func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) 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 MakeFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, ...](f F) ...
  • func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r R, panicErr error)
  • func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) 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 MakeFuncVar16[...](f F) ...
  • func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r R, panicErr error)
  • func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) 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 MakeFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](f F) FuncVar2[A1, A2, VA, R]
  • func (f FuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, 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() DelegateFuncVar2[A1, A2, VA, R]
• type FuncVar3
  • func MakeFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]
  • func (f FuncVar3[A1, A2, A3, VA, R]) 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() DelegateFuncVar3[A1, A2, A3, VA, R]
• type FuncVar4
  • func MakeFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](f F) FuncVar4[A1, A2, A3, A4, VA, R]
  • func (f FuncVar4[A1, A2, A3, A4, VA, R]) 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() DelegateFuncVar4[A1, A2, A3, A4, VA, R]
• type FuncVar5
  • func MakeFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(A1, A2, A3, A4, A5, ...VA) R](f F) FuncVar5[A1, A2, A3, A4, A5, VA, R]
  • func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) 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() DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]
• type FuncVar6
  • func MakeFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(A1, A2, A3, A4, A5, A6, ...VA) R](f F) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]
  • func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) 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() DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]
• type FuncVar7
  • func MakeFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, ...](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
  • func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) 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() DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]
• type FuncVar8
  • func MakeFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, ...](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
  • func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) 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() DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]
• type FuncVar9
  • func MakeFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, ...](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]
  • func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) 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() DelegateFuncVar9[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 PairFunc0
  • func MakePairFunc0[R1, R2 any, F ~func() (R1, R2)](f F) PairFunc0[R1, R2]
  • func (f PairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc0[R1, R2]) Exec() (r1 R1, r2 R2)
  • func (f PairFunc0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc0[R1, R2]) ToDelegate() DelegatePairFunc0[R1, R2]
• type PairFunc1
  • func MakePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) PairFunc1[A1, R1, R2]
  • func (f PairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)
  • func (f PairFunc1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc1[A1, R1, R2]) ToDelegate() DelegatePairFunc1[A1, R1, R2]
• type PairFunc10
  • func MakePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, ...](f F) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
  • func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10) (r1 R1, r2 R2)
  • func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate() DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]
• type PairFunc11
  • func MakePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, ...](f F) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
  • func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate() DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]
• type PairFunc12
  • func MakePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, ...](f F) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
  • func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate() DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]
• type PairFunc13
  • func MakePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, ...](f F) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]
  • func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate() ...
• type PairFunc14
  • func MakePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, ...](f F) ...
  • func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate() ...
• type PairFunc15
  • func MakePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, ...](f F) ...
  • func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate() ...
• type PairFunc16
  • func MakePairFunc16[...](f F) ...
  • func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate() ...
• type PairFunc2
  • func MakePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) PairFunc2[A1, A2, R1, R2]
  • func (f PairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)
  • func (f PairFunc2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc2[A1, A2, R1, R2]) ToDelegate() DelegatePairFunc2[A1, A2, R1, R2]
• type PairFunc3
  • func MakePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) PairFunc3[A1, A2, A3, R1, R2]
  • func (f PairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)
  • func (f PairFunc3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc3[A1, A2, A3, R1, R2]) ToDelegate() DelegatePairFunc3[A1, A2, A3, R1, R2]
• type PairFunc4
  • func MakePairFunc4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](f F) PairFunc4[A1, A2, A3, A4, R1, R2]
  • func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)
  • func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc4[A1, A2, A3, A4, R1, R2]) ToDelegate() DelegatePairFunc4[A1, A2, A3, A4, R1, R2]
• type PairFunc5
  • func MakePairFunc5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(A1, A2, A3, A4, A5) (R1, R2)](f F) PairFunc5[A1, A2, A3, A4, A5, R1, R2]
  • func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2)
  • func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate() DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]
• type PairFunc6
  • func MakePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(A1, A2, A3, A4, A5, A6) (R1, R2)](f F) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]
  • func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2)
  • func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate() DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]
• type PairFunc7
  • func MakePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, ...](f F) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
  • func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r1 R1, r2 R2)
  • func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate() DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]
• type PairFunc8
  • func MakePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, ...](f F) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
  • func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r1 R1, r2 R2)
  • func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate() DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]
• type PairFunc9
  • func MakePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, ...](f F) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
  • func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r1 R1, r2 R2)
  • func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9) (r1 R1, r2 R2, panicErr error)
  • func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate() DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]
• type PairFuncVar0
  • func MakePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) PairFuncVar0[VA, R1, R2]
  • func (f PairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar0[VA, R1, R2]) Exec(args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar0[VA, R1, R2]) Invoke(args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar0[VA, R1, R2]) ToDelegate() DelegatePairFuncVar0[VA, R1, R2]
• type PairFuncVar1
  • func MakePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) PairFuncVar1[A1, VA, R1, R2]
  • func (f PairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar1[A1, VA, R1, R2]) Exec(a1 A1, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar1[A1, VA, R1, R2]) Invoke(a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar1[A1, VA, R1, R2]) ToDelegate() DelegatePairFuncVar1[A1, VA, R1, R2]
• type PairFuncVar10
  • func MakePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, ...](f F) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
  • func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate() DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]
• type PairFuncVar11
  • func MakePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, ...](f F) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]
  • func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate() ...
• type PairFuncVar12
  • func MakePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, ...](f F) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]
  • func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate() ...
• type PairFuncVar13
  • func MakePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, ...](f F) ...
  • func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate() ...
• type PairFuncVar14
  • func MakePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, ...](f F) ...
  • func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate() ...
• type PairFuncVar15
  • func MakePairFuncVar15[...](f F) ...
  • func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate() ...
• type PairFuncVar16
  • func MakePairFuncVar16[...](f F) ...
  • func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2)
  • func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate() ...
• type PairFuncVar2
  • func MakePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) PairFuncVar2[A1, A2, VA, R1, R2]
  • func (f PairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar2[A1, A2, VA, R1, R2]) ToDelegate() DelegatePairFuncVar2[A1, A2, VA, R1, R2]
• type PairFuncVar3
  • func MakePairFuncVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](f F) PairFuncVar3[A1, A2, A3, VA, R1, R2]
  • func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) ToDelegate() DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]
• type PairFuncVar4
  • func MakePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](f F) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]
  • func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar4[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 PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate() DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]
• type PairFuncVar5
  • func MakePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, ...](f F) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]
  • func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate() DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]
• type PairFuncVar6
  • func MakePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, ...](f F) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
  • func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate() DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]
• type PairFuncVar7
  • func MakePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, ...](f F) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
  • func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r1 R1, r2 R2)
  • func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate() DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]
• type PairFuncVar8
  • func MakePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, ...](f F) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
  • func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) 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 PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate() DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]
• type PairFuncVar9
  • func MakePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, ...](f F) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
  • func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, ...) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) 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 PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA) (r1 R1, r2 R2, panicErr error)
  • func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate() DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]
• 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]) 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]) 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 PairFuncError

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

Types

type Action0

type Action0 func()

func MakeAction0

func MakeAction0[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() DelegateAction0

type Action1

type Action1[A1 any] func(A1)

func MakeAction1

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

func (Action1[A1]) Call

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

func (Action1[A1]) 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() DelegateAction1[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 MakeAction10

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (Action15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]) 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() DelegateAction15[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 MakeAction16

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

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

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

func (Action16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]) 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() DelegateAction16[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 MakeAction2

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

func (Action2[A1, A2]) Call

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

func (Action2[A1, A2]) 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() DelegateAction2[A1, A2]

type Action3

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

func MakeAction3

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

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

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

func (Action3[A1, A2, A3]) 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() DelegateAction3[A1, A2, A3]

type Action4

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

func MakeAction4

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

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

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

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

type Action5

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

func MakeAction5

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

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

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

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

type Action6

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

func MakeAction6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type ActionVar0

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

func MakeActionVar0

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

func (ActionVar0[VA]) Call

func (f ActionVar0[VA]) Call(autoRecover bool, reportError chan error, 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() DelegateActionVar0[VA]

type ActionVar1

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

func MakeActionVar1

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

func (ActionVar1[A1, VA]) Call

func (f ActionVar1[A1, VA]) Call(autoRecover bool, reportError chan error, a1 A1, 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() DelegateActionVar1[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 MakeActionVar10

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

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

func (f ActionVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, 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() DelegateActionVar10[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 MakeActionVar11

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

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

func (f ActionVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, 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() DelegateActionVar11[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 MakeActionVar12

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

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

func (f ActionVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, 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() DelegateActionVar12[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 MakeActionVar13

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

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

func (f ActionVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, 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() DelegateActionVar13[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 MakeActionVar14

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

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

func (f ActionVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, 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() DelegateActionVar14[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 MakeActionVar15

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

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

func (f ActionVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, 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() DelegateActionVar15[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 MakeActionVar16

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

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

func (f ActionVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, 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() DelegateActionVar16[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 MakeActionVar2

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

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

func (f ActionVar2[A1, A2, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, 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() DelegateActionVar2[A1, A2, VA]

type ActionVar3

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

func MakeActionVar3

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

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

func (f ActionVar3[A1, A2, A3, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, 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() DelegateActionVar3[A1, A2, A3, VA]

type ActionVar4

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

func MakeActionVar4

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

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

func (f ActionVar4[A1, A2, A3, A4, VA]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, 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() DelegateActionVar4[A1, A2, A3, A4, VA]

type ActionVar5

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

func MakeActionVar5

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

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

func (f ActionVar5[A1, A2, A3, A4, A5, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, 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() DelegateActionVar5[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 MakeActionVar6

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

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

func (f ActionVar6[A1, A2, A3, A4, A5, A6, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, 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() DelegateActionVar6[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 MakeActionVar7

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

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

func (f ActionVar7[A1, A2, A3, A4, A5, A6, A7, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, 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() DelegateActionVar7[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 MakeActionVar8

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

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

func (f ActionVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, 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() DelegateActionVar8[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 MakeActionVar9

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

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

func (f ActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, 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() DelegateActionVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA]

type DelegateAction0

type DelegateAction0 []Action0

func MakeDelegateAction0

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

func (DelegateAction0) Call

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

func (DelegateAction0) Exec

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

func (DelegateAction0) Invoke

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

func (DelegateAction0) ToAction

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

type DelegateAction1

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

func MakeDelegateAction1

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

func (DelegateAction1[A1]) Call

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

func (DelegateAction1[A1]) Exec

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

func (DelegateAction1[A1]) Invoke

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

func (DelegateAction1[A1]) ToAction

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

type DelegateAction10

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

func MakeDelegateAction10

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

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

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

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

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

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

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

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

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

type DelegateAction11

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

func MakeDelegateAction11

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

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

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

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

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

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

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

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

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

type DelegateAction12

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

func MakeDelegateAction12

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

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

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

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

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

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

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

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

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

type DelegateAction13

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

func MakeDelegateAction13

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

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

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

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

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

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

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

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

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

type DelegateAction14

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

func MakeDelegateAction14

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

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

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

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

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

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

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

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

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

type DelegateAction15

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

func MakeDelegateAction15

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

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

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

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

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

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

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

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

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

type DelegateAction16

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

func MakeDelegateAction16

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

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

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

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

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

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

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

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

func (d DelegateAction16[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 DelegateAction2

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

func MakeDelegateAction2

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

func (DelegateAction2[A1, A2]) Call

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

func (DelegateAction2[A1, A2]) Exec

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

func (DelegateAction2[A1, A2]) Invoke

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

func (DelegateAction2[A1, A2]) ToAction

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

type DelegateAction3

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

func MakeDelegateAction3

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

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

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

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

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

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

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

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

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

type DelegateAction4

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

func MakeDelegateAction4

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

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

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

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

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

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

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

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

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

type DelegateAction5

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

func MakeDelegateAction5

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

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

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

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

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

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

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

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

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

type DelegateAction6

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

func MakeDelegateAction6

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

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

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

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

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

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

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

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

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

type DelegateAction7

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

func MakeDelegateAction7

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

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

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

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

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

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

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

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

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

type DelegateAction8

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

func MakeDelegateAction8

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

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

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

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

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

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

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

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

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

type DelegateAction9

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

func MakeDelegateAction9

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

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

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

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

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

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

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

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

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

type DelegateActionVar0

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

func MakeDelegateActionVar0

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

func (DelegateActionVar0[VA]) Call

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

func (DelegateActionVar0[VA]) Exec

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

func (DelegateActionVar0[VA]) Invoke

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

func (DelegateActionVar0[VA]) ToAction

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

type DelegateActionVar1

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

func MakeDelegateActionVar1

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

func (DelegateActionVar1[A1, VA]) Call

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

func (DelegateActionVar1[A1, VA]) Exec

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

func (DelegateActionVar1[A1, VA]) Invoke

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

func (DelegateActionVar1[A1, VA]) ToAction

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

type DelegateActionVar10

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

func MakeDelegateActionVar10

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

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

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

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

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

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

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

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

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

type DelegateActionVar11

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

func MakeDelegateActionVar11

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

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

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

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

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

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

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

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

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

type DelegateActionVar12

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

func MakeDelegateActionVar12

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

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

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

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

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

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

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

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

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

type DelegateActionVar13

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

func MakeDelegateActionVar13

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

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

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

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

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

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

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

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

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

type DelegateActionVar14

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

func MakeDelegateActionVar14

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

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

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

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

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

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

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

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

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

type DelegateActionVar15

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

func MakeDelegateActionVar15

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

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

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

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

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

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

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

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

func (d DelegateActionVar15[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 DelegateActionVar16

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

func MakeDelegateActionVar16

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

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

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

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

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

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

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

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

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

type DelegateActionVar2

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

func MakeDelegateActionVar2

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

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

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

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

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

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

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

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

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

type DelegateActionVar3

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

func MakeDelegateActionVar3

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

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

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

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

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

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

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

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

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

type DelegateActionVar4

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

func MakeDelegateActionVar4

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

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

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

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

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

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

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

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

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

type DelegateActionVar5

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

func MakeDelegateActionVar5

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

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

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

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

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

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

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

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

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

type DelegateActionVar6

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

func MakeDelegateActionVar6

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

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

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

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

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

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

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

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

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

type DelegateActionVar7

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

func MakeDelegateActionVar7

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

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

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

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

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

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

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

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

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

type DelegateActionVar8

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

func MakeDelegateActionVar8

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

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

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

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

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

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

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

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

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

type DelegateActionVar9

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

func MakeDelegateActionVar9

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

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

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

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

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

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

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

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

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

type DelegateFunc0

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

func MakeDelegateFunc0

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

func (DelegateFunc0[R]) Call

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

func (DelegateFunc0[R]) Exec

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

func (DelegateFunc0[R]) Invoke

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

func (DelegateFunc0[R]) ToFunc

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

type DelegateFunc1

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

func MakeDelegateFunc1

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

func (DelegateFunc1[A1, R]) Call

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

func (DelegateFunc1[A1, R]) Exec

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

func (DelegateFunc1[A1, R]) Invoke

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

func (DelegateFunc1[A1, R]) ToFunc

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

type DelegateFunc10

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

func MakeDelegateFunc10

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

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

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

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

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

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

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

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

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

type DelegateFunc11

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

func MakeDelegateFunc11

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

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

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

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

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

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

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

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

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

type DelegateFunc12

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

func MakeDelegateFunc12

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

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

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

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

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

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

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

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

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

type DelegateFunc13

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

func MakeDelegateFunc13

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

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

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

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

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

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

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

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

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

type DelegateFunc14

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

func MakeDelegateFunc14

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

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

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

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

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

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

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

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

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

type DelegateFunc15

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

func MakeDelegateFunc15

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

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

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

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

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

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

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

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

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

type DelegateFunc16

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

func MakeDelegateFunc16

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

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

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

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

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

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

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

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

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

type DelegateFunc2

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

func MakeDelegateFunc2

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

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

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

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

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

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

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

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

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

type DelegateFunc3

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

func MakeDelegateFunc3

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

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

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

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

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

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

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

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

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

type DelegateFunc4

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

func MakeDelegateFunc4

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

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

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

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

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

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

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

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

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

type DelegateFunc5

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

func MakeDelegateFunc5

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

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

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

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

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

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

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

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

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

type DelegateFunc6

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

func MakeDelegateFunc6

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

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

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

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

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

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

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

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

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

type DelegateFunc7

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

func MakeDelegateFunc7

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

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

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

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

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

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

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

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

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

type DelegateFunc8

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

func MakeDelegateFunc8

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

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

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

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

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

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

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

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

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

type DelegateFunc9

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

func MakeDelegateFunc9

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

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

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

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

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

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

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

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

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

type DelegateFuncVar0

type DelegateFuncVar0[VA, R any] []FuncVar0[VA, R]

func MakeDelegateFuncVar0

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

func (DelegateFuncVar0[VA, R]) Call

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

func (DelegateFuncVar0[VA, R]) Exec

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

func (DelegateFuncVar0[VA, R]) Invoke

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

func (DelegateFuncVar0[VA, R]) ToFunc

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

type DelegateFuncVar1

type DelegateFuncVar1[A1, VA, R any] []FuncVar1[A1, VA, R]

func MakeDelegateFuncVar1

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

func (DelegateFuncVar1[A1, VA, R]) Call

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

func (DelegateFuncVar1[A1, VA, R]) Exec

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

func (DelegateFuncVar1[A1, VA, R]) Invoke

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

func (DelegateFuncVar1[A1, VA, R]) ToFunc

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

type DelegateFuncVar10

type DelegateFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any] []FuncVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R,
]

func MakeDelegateFuncVar10

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

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

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

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

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

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

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

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

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

type DelegateFuncVar11

type DelegateFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any] []FuncVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R,
]

func MakeDelegateFuncVar11

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

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

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

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

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

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

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

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

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

type DelegateFuncVar12

type DelegateFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any] []FuncVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R,
]

func MakeDelegateFuncVar12

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

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

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

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

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

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

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

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

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

type DelegateFuncVar13

type DelegateFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any] []FuncVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R,
]

func MakeDelegateFuncVar13

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

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

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

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

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

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

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

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

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

type DelegateFuncVar14

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

func MakeDelegateFuncVar14

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

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

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

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

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

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

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

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

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

type DelegateFuncVar15

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

func MakeDelegateFuncVar15

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

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

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

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

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

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

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

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

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

type DelegateFuncVar16

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

func MakeDelegateFuncVar16

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

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

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

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

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

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

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

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

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

type DelegateFuncVar2

type DelegateFuncVar2[A1, A2, VA, R any] []FuncVar2[A1, A2, VA, R]

func MakeDelegateFuncVar2

func MakeDelegateFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](fs ...F) DelegateFuncVar2[A1, A2, VA, R]

func (DelegateFuncVar2[A1, A2, VA, R]) Call

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

func (DelegateFuncVar2[A1, A2, VA, R]) Exec

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

func (DelegateFuncVar2[A1, A2, VA, R]) Invoke

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

func (DelegateFuncVar2[A1, A2, VA, R]) ToFunc

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

type DelegateFuncVar3

type DelegateFuncVar3[A1, A2, A3, VA, R any] []FuncVar3[A1, A2, A3, VA, R]

func MakeDelegateFuncVar3

func MakeDelegateFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](fs ...F) DelegateFuncVar3[A1, A2, A3, VA, R]

func (DelegateFuncVar3[A1, A2, A3, VA, R]) Call

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

func (DelegateFuncVar3[A1, A2, A3, VA, R]) Exec

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

func (DelegateFuncVar3[A1, A2, A3, VA, R]) Invoke

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

func (DelegateFuncVar3[A1, A2, A3, VA, R]) ToFunc

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

type DelegateFuncVar4

type DelegateFuncVar4[A1, A2, A3, A4, VA, R any] []FuncVar4[A1, A2, A3, A4, VA, R]

func MakeDelegateFuncVar4

func MakeDelegateFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](fs ...F) DelegateFuncVar4[A1, A2, A3, A4, VA, R]

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

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

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

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

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

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

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

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

type DelegateFuncVar5

type DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R any] []FuncVar5[
	A1, A2, A3, A4, A5, VA, R,
]

func MakeDelegateFuncVar5

func MakeDelegateFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) R](fs ...F) DelegateFuncVar5[A1, A2, A3, A4, A5, VA, R]

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

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

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

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

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

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

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

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

type DelegateFuncVar6

type DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any] []FuncVar6[
	A1, A2, A3, A4, A5, A6, VA, R,
]

func MakeDelegateFuncVar6

func MakeDelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R](fs ...F) DelegateFuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

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

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

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

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

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

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

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

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

type DelegateFuncVar7

type DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any] []FuncVar7[
	A1, A2, A3, A4, A5, A6, A7, VA, R,
]

func MakeDelegateFuncVar7

func MakeDelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R](fs ...F) DelegateFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

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

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

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

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

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

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

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

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

type DelegateFuncVar8

type DelegateFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any] []FuncVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA, R,
]

func MakeDelegateFuncVar8

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

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

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

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

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

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

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

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

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

type DelegateFuncVar9

type DelegateFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any] []FuncVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R,
]

func MakeDelegateFuncVar9

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

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

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

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

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

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

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

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

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

type DelegatePairFunc0

type DelegatePairFunc0[R1, R2 any] []PairFunc0[R1, R2]

func MakeDelegatePairFunc0

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

func (DelegatePairFunc0[R1, R2]) Call

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

func (DelegatePairFunc0[R1, R2]) Exec

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

func (DelegatePairFunc0[R1, R2]) Invoke

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

func (DelegatePairFunc0[R1, R2]) ToFunc

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

type DelegatePairFunc1

type DelegatePairFunc1[A1, R1, R2 any] []PairFunc1[A1, R1, R2]

func MakeDelegatePairFunc1

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

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

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

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

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

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

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

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

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

type DelegatePairFunc10

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

func MakeDelegatePairFunc10

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

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

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

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

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

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

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

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

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

type DelegatePairFunc11

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

func MakeDelegatePairFunc11

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

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

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

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

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

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

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

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

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

type DelegatePairFunc12

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

func MakeDelegatePairFunc12

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

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

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

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

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

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

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

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

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

type DelegatePairFunc13

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

func MakeDelegatePairFunc13

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

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

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

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

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

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

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

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

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

type DelegatePairFunc14

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

func MakeDelegatePairFunc14

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

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

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

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

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

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

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

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

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

type DelegatePairFunc15

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

func MakeDelegatePairFunc15

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

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

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

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

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

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

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

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

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

type DelegatePairFunc16

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

func MakeDelegatePairFunc16

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

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

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

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

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

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

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

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

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

type DelegatePairFunc2

type DelegatePairFunc2[A1, A2, R1, R2 any] []PairFunc2[A1, A2, R1, R2]

func MakeDelegatePairFunc2

func MakeDelegatePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](fs ...F) DelegatePairFunc2[A1, A2, R1, R2]

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

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

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

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

func (DelegatePairFunc2[A1, A2, R1, R2]) Invoke

func (d DelegatePairFunc2[A1, A2, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc2[A1, A2, R1, R2]) ToFunc

func (d DelegatePairFunc2[A1, A2, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc2[A1, A2, R1, R2]

type DelegatePairFunc3

type DelegatePairFunc3[A1, A2, A3, R1, R2 any] []PairFunc3[A1, A2, A3, R1, R2]

func MakeDelegatePairFunc3

func MakeDelegatePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](fs ...F) DelegatePairFunc3[A1, A2, A3, R1, R2]

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) Call

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) Exec

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) Invoke

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc3[A1, A2, A3, R1, R2]) ToFunc

func (d DelegatePairFunc3[A1, A2, A3, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc3[A1, A2, A3, R1, R2]

type DelegatePairFunc4

type DelegatePairFunc4[A1, A2, A3, A4, R1, R2 any] []PairFunc4[A1, A2, A3, A4, R1, R2]

func MakeDelegatePairFunc4

func MakeDelegatePairFunc4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](fs ...F) DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Call

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Exec

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Invoke

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) ToFunc

func (d DelegatePairFunc4[A1, A2, A3, A4, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc4[A1, A2, A3, A4, R1, R2]

type DelegatePairFunc5

type DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2 any] []PairFunc5[
	A1, A2, A3, A4, A5, R1, R2,
]

func MakeDelegatePairFunc5

func MakeDelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5,
) (R1, R2)](fs ...F) DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2)

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToFunc

func (d DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc5[A1, A2, A3, A4, A5, R1, R2]

type DelegatePairFunc6

type DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any] []PairFunc6[
	A1, A2, A3, A4, A5, A6, R1, R2,
]

func MakeDelegatePairFunc6

func MakeDelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)](fs ...F) DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2)

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc

func (d DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

type DelegatePairFunc7

type DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any] []PairFunc7[
	A1, A2, A3, A4, A5, A6, A7, R1, R2,
]

func MakeDelegatePairFunc7

func MakeDelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)](fs ...F) DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2)

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc

func (d DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

type DelegatePairFunc8

type DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any] []PairFunc8[
	A1, A2, A3, A4, A5, A6, A7, A8, R1, R2,
]

func MakeDelegatePairFunc8

func MakeDelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)](fs ...F) DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2)

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc

func (d DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

type DelegatePairFunc9

type DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any] []PairFunc9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2,
]

func MakeDelegatePairFunc9

func MakeDelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)](fs ...F) DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2)

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc

func (d DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type DelegatePairFuncVar0

type DelegatePairFuncVar0[VA, R1, R2 any] []PairFuncVar0[VA, R1, R2]

func MakeDelegatePairFuncVar0

func MakeDelegatePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](fs ...F) DelegatePairFuncVar0[VA, R1, R2]

func (DelegatePairFuncVar0[VA, R1, R2]) Call

func (d DelegatePairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar0[VA, R1, R2]) Exec

func (d DelegatePairFuncVar0[VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar0[VA, R1, R2]) Invoke

func (d DelegatePairFuncVar0[VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar0[VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar0[VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar0[VA, R1, R2]

type DelegatePairFuncVar1

type DelegatePairFuncVar1[A1, VA, R1, R2 any] []PairFuncVar1[A1, VA, R1, R2]

func MakeDelegatePairFuncVar1

func MakeDelegatePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar1[A1, VA, R1, R2]

func (DelegatePairFuncVar1[A1, VA, R1, R2]) Call

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar1[A1, VA, R1, R2]) Exec

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar1[A1, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar1[A1, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar1[A1, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar1[A1, VA, R1, R2]

type DelegatePairFuncVar10

type DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any] []PairFuncVar10[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2,
]

func MakeDelegatePairFuncVar10

func MakeDelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

type DelegatePairFuncVar11

type DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any] []PairFuncVar11[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2,
]

func MakeDelegatePairFuncVar11

func MakeDelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

type DelegatePairFuncVar12

type DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any] []PairFuncVar12[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2,
]

func MakeDelegatePairFuncVar12

func MakeDelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

type DelegatePairFuncVar13

type DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any] []PairFuncVar13[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2,
]

func MakeDelegatePairFuncVar13

func MakeDelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

type DelegatePairFuncVar14

type DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any] []PairFuncVar14[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2,
]

func MakeDelegatePairFuncVar14

func MakeDelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

type DelegatePairFuncVar15

type DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any] []PairFuncVar15[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2,
]

func MakeDelegatePairFuncVar15

func MakeDelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

type DelegatePairFuncVar16

type DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any] []PairFuncVar16[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2,
]

func MakeDelegatePairFuncVar16

func MakeDelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

type DelegatePairFuncVar2

type DelegatePairFuncVar2[A1, A2, VA, R1, R2 any] []PairFuncVar2[A1, A2, VA, R1, R2]

func MakeDelegatePairFuncVar2

func MakeDelegatePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar2[A1, A2, VA, R1, R2]

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Call

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Exec

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar2[A1, A2, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar2[A1, A2, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar2[A1, A2, VA, R1, R2]

type DelegatePairFuncVar3

type DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2 any] []PairFuncVar3[A1, A2, A3, VA, R1, R2]

func MakeDelegatePairFuncVar3

func MakeDelegatePairFuncVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Call

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar3[A1, A2, A3, VA, R1, R2]

type DelegatePairFuncVar4

type DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any] []PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func MakeDelegatePairFuncVar4

func MakeDelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](fs ...F) DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool], a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

type DelegatePairFuncVar5

type DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any] []PairFuncVar5[
	A1, A2, A3, A4, A5, VA, R1, R2,
]

func MakeDelegatePairFuncVar5

func MakeDelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

type DelegatePairFuncVar6

type DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any] []PairFuncVar6[
	A1, A2, A3, A4, A5, A6, VA, R1, R2,
]

func MakeDelegatePairFuncVar6

func MakeDelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

type DelegatePairFuncVar7

type DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any] []PairFuncVar7[
	A1, A2, A3, A4, A5, A6, A7, VA, R1, R2,
]

func MakeDelegatePairFuncVar7

func MakeDelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

type DelegatePairFuncVar8

type DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any] []PairFuncVar8[
	A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2,
]

func MakeDelegatePairFuncVar8

func MakeDelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

type DelegatePairFuncVar9

type DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any] []PairFuncVar9[
	A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2,
]

func MakeDelegatePairFuncVar9

func MakeDelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)](fs ...F) DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error, interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2)

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(interrupt Func3[R1, R2, error, bool],
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc

func (d DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToFunc(interrupt Func3[R1, R2, error, bool]) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

type Func0

type Func0[R any] func() R

func MakeFunc0

func MakeFunc0[R any, F ~func() R](f F) Func0[R]

func (Func0[R]) Call

func (f Func0[R]) Call(autoRecover bool, reportError chan error) (r R, panicErr error)

func (Func0[R]) 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() DelegateFunc0[R]

type Func1

type Func1[A1, R any] func(A1) R

func MakeFunc1

func MakeFunc1[A1, R any, F ~func(A1) R](f F) Func1[A1, R]

func (Func1[A1, R]) Call

func (f Func1[A1, R]) Call(autoRecover bool, reportError chan error, a1 A1) (r R, panicErr error)

func (Func1[A1, R]) 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() DelegateFunc1[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 MakeFunc10

func MakeFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) R](f F) Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call

func (f Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r R, panicErr error)

func (Func10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R]) 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() DelegateFunc10[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 MakeFunc11

func MakeFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) R](f F) Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call

func (f Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r R, panicErr error)

func (Func11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R]) 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() DelegateFunc11[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 MakeFunc12

func MakeFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) R](f F) Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call

func (f Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r R, panicErr error)

func (Func12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R]) 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() DelegateFunc12[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 MakeFunc13

func MakeFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) R](f F) Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call

func (f Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r R, panicErr error)

func (Func13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R]) 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() DelegateFunc13[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 MakeFunc14

func MakeFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) R](f F) Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call

func (f Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r R, panicErr error)

func (Func14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R]) 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() DelegateFunc14[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 MakeFunc15

func MakeFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) R](f F) Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call

func (f Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r R, panicErr error)

func (Func15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R]) 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() DelegateFunc15[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 MakeFunc16

func MakeFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) R](f F) Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call

func (f Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r R, panicErr error)

func (Func16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R]) 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() DelegateFunc16[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 MakeFunc2

func MakeFunc2[A1, A2, R any, F ~func(A1, A2) R](f F) Func2[A1, A2, R]

func (Func2[A1, A2, R]) Call

func (f Func2[A1, A2, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r R, panicErr error)

func (Func2[A1, A2, R]) 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() DelegateFunc2[A1, A2, R]

type Func3

type Func3[A1, A2, A3, R any] func(A1, A2, A3) R

func MakeFunc3

func MakeFunc3[A1, A2, A3, R any, F ~func(A1, A2, A3) R](f F) Func3[A1, A2, A3, R]

func (Func3[A1, A2, A3, R]) Call

func (f Func3[A1, A2, A3, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r R, panicErr error)

func (Func3[A1, A2, A3, R]) 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() DelegateFunc3[A1, A2, A3, R]

type Func4

type Func4[A1, A2, A3, A4, R any] func(A1, A2, A3, A4) R

func MakeFunc4

func MakeFunc4[A1, A2, A3, A4, R any, F ~func(A1, A2, A3, A4) R](f F) Func4[A1, A2, A3, A4, R]

func (Func4[A1, A2, A3, A4, R]) Call

func (f Func4[A1, A2, A3, A4, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r R, panicErr error)

func (Func4[A1, A2, A3, A4, R]) 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() DelegateFunc4[A1, A2, A3, A4, R]

type Func5

type Func5[A1, A2, A3, A4, A5, R any] func(
	A1, A2, A3, A4, A5,
) R

func MakeFunc5

func MakeFunc5[A1, A2, A3, A4, A5, R any, F ~func(
	A1, A2, A3, A4, A5,
) R](f F) Func5[A1, A2, A3, A4, A5, R]

func (Func5[A1, A2, A3, A4, A5, R]) Call

func (f Func5[A1, A2, A3, A4, A5, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r R, panicErr error)

func (Func5[A1, A2, A3, A4, A5, R]) 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() DelegateFunc5[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 MakeFunc6

func MakeFunc6[A1, A2, A3, A4, A5, A6, R any, F ~func(
	A1, A2, A3, A4, A5, A6,
) R](f F) Func6[A1, A2, A3, A4, A5, A6, R]

func (Func6[A1, A2, A3, A4, A5, A6, R]) Call

func (f Func6[A1, A2, A3, A4, A5, A6, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r R, panicErr error)

func (Func6[A1, A2, A3, A4, A5, A6, R]) 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() DelegateFunc6[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 MakeFunc7

func MakeFunc7[A1, A2, A3, A4, A5, A6, A7, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) R](f F) Func7[A1, A2, A3, A4, A5, A6, A7, R]

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) Call

func (f Func7[A1, A2, A3, A4, A5, A6, A7, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r R, panicErr error)

func (Func7[A1, A2, A3, A4, A5, A6, A7, R]) 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() DelegateFunc7[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 MakeFunc8

func MakeFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) R](f F) Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call

func (f Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r R, panicErr error)

func (Func8[A1, A2, A3, A4, A5, A6, A7, A8, R]) 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() DelegateFunc8[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 MakeFunc9

func MakeFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) R](f F) Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call

func (f Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r R, panicErr error)

func (Func9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]) 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() DelegateFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R]

type FuncVar0

type FuncVar0[VA, R any] func(...VA) R

func MakeFuncVar0

func MakeFuncVar0[VA, R any, F ~func(...VA) R](f F) FuncVar0[VA, R]

func (FuncVar0[VA, R]) Call

func (f FuncVar0[VA, R]) Call(autoRecover bool, reportError chan error, 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() DelegateFuncVar0[VA, R]

type FuncVar1

type FuncVar1[A1, VA, R any] func(A1, ...VA) R

func MakeFuncVar1

func MakeFuncVar1[A1, VA, R any, F ~func(A1, ...VA) R](f F) FuncVar1[A1, VA, R]

func (FuncVar1[A1, VA, R]) Call

func (f FuncVar1[A1, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, 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() DelegateFuncVar1[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 MakeFuncVar10

func MakeFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) R](f F) FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]

func (FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call

func (f FuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, 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() DelegateFuncVar10[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 MakeFuncVar11

func MakeFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) R](f F) FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]

func (FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call

func (f FuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, 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() DelegateFuncVar11[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 MakeFuncVar12

func MakeFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) R](f F) FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]

func (FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call

func (f FuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, 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() DelegateFuncVar12[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 MakeFuncVar13

func MakeFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) R](f F) FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]

func (FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call

func (f FuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, 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() DelegateFuncVar13[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 MakeFuncVar14

func MakeFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) R](f F) FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]

func (FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call

func (f FuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, 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() DelegateFuncVar14[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 MakeFuncVar15

func MakeFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) R](f F) FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]

func (FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call

func (f FuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, 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() DelegateFuncVar15[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 MakeFuncVar16

func MakeFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) R](f F) FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]

func (FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call

func (f FuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, 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() DelegateFuncVar16[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 MakeFuncVar2

func MakeFuncVar2[A1, A2, VA, R any, F ~func(A1, A2, ...VA) R](f F) FuncVar2[A1, A2, VA, R]

func (FuncVar2[A1, A2, VA, R]) Call

func (f FuncVar2[A1, A2, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, 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() DelegateFuncVar2[A1, A2, VA, R]

type FuncVar3

type FuncVar3[A1, A2, A3, VA, R any] func(A1, A2, A3, ...VA) R

func MakeFuncVar3

func MakeFuncVar3[A1, A2, A3, VA, R any, F ~func(A1, A2, A3, ...VA) R](f F) FuncVar3[A1, A2, A3, VA, R]

func (FuncVar3[A1, A2, A3, VA, R]) Call

func (f FuncVar3[A1, A2, A3, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, 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() DelegateFuncVar3[A1, A2, A3, VA, R]

type FuncVar4

type FuncVar4[A1, A2, A3, A4, VA, R any] func(A1, A2, A3, A4, ...VA) R

func MakeFuncVar4

func MakeFuncVar4[A1, A2, A3, A4, VA, R any, F ~func(A1, A2, A3, A4, ...VA) R](f F) FuncVar4[A1, A2, A3, A4, VA, R]

func (FuncVar4[A1, A2, A3, A4, VA, R]) Call

func (f FuncVar4[A1, A2, A3, A4, VA, R]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, 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() DelegateFuncVar4[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 MakeFuncVar5

func MakeFuncVar5[A1, A2, A3, A4, A5, VA, R any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) R](f F) FuncVar5[A1, A2, A3, A4, A5, VA, R]

func (FuncVar5[A1, A2, A3, A4, A5, VA, R]) Call

func (f FuncVar5[A1, A2, A3, A4, A5, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, 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() DelegateFuncVar5[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 MakeFuncVar6

func MakeFuncVar6[A1, A2, A3, A4, A5, A6, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) R](f F) FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]

func (FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call

func (f FuncVar6[A1, A2, A3, A4, A5, A6, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, 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() DelegateFuncVar6[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 MakeFuncVar7

func MakeFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) R](f F) FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]

func (FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call

func (f FuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, 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() DelegateFuncVar7[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 MakeFuncVar8

func MakeFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) R](f F) FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]

func (FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call

func (f FuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, 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() DelegateFuncVar8[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 MakeFuncVar9

func MakeFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) R](f F) FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]

func (FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call

func (f FuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, 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() DelegateFuncVar9[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 PairFunc0

type PairFunc0[R1, R2 any] func() (R1, R2)

func MakePairFunc0

func MakePairFunc0[R1, R2 any, F ~func() (R1, R2)](f F) PairFunc0[R1, R2]

func (PairFunc0[R1, R2]) Call

func (f PairFunc0[R1, R2]) Call(autoRecover bool, reportError chan error) (r1 R1, r2 R2, panicErr error)

func (PairFunc0[R1, R2]) Exec

func (f PairFunc0[R1, R2]) Exec() (r1 R1, r2 R2)

func (PairFunc0[R1, R2]) Invoke

func (f PairFunc0[R1, R2]) Invoke() (r1 R1, r2 R2, panicErr error)

func (PairFunc0[R1, R2]) ToDelegate

func (f PairFunc0[R1, R2]) ToDelegate() DelegatePairFunc0[R1, R2]

type PairFunc1

type PairFunc1[A1, R1, R2 any] func(A1) (R1, R2)

func MakePairFunc1

func MakePairFunc1[A1, R1, R2 any, F ~func(A1) (R1, R2)](f F) PairFunc1[A1, R1, R2]

func (PairFunc1[A1, R1, R2]) Call

func (f PairFunc1[A1, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1) (r1 R1, r2 R2, panicErr error)

func (PairFunc1[A1, R1, R2]) Exec

func (f PairFunc1[A1, R1, R2]) Exec(a1 A1) (r1 R1, r2 R2)

func (PairFunc1[A1, R1, R2]) Invoke

func (f PairFunc1[A1, R1, R2]) Invoke(a1 A1) (r1 R1, r2 R2, panicErr error)

func (PairFunc1[A1, R1, R2]) ToDelegate

func (f PairFunc1[A1, R1, R2]) ToDelegate() DelegatePairFunc1[A1, R1, R2]

type PairFunc10

type PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)

func MakePairFunc10

func MakePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10,
) (R1, R2)](f F) PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2)

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate

func (f PairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]) ToDelegate() DelegatePairFunc10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R1, R2]

type PairFunc11

type PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)

func MakePairFunc11

func MakePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11,
) (R1, R2)](f F) PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2)

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate

func (f PairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]) ToDelegate() DelegatePairFunc11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R1, R2]

type PairFunc12

type PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)

func MakePairFunc12

func MakePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12,
) (R1, R2)](f F) PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2)

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate

func (f PairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]) ToDelegate() DelegatePairFunc12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R1, R2]

type PairFunc13

type PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)

func MakePairFunc13

func MakePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13,
) (R1, R2)](f F) PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2)

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate

func (f PairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]) ToDelegate() DelegatePairFunc13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R1, R2]

type PairFunc14

type PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)

func MakePairFunc14

func MakePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14,
) (R1, R2)](f F) PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2)

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate

func (f PairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]) ToDelegate() DelegatePairFunc14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R1, R2]

type PairFunc15

type PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)

func MakePairFunc15

func MakePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15,
) (R1, R2)](f F) PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2)

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate

func (f PairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]) ToDelegate() DelegatePairFunc15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R1, R2]

type PairFunc16

type PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)

func MakePairFunc16

func MakePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
) (R1, R2)](f F) PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2)

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate

func (f PairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]) ToDelegate() DelegatePairFunc16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R1, R2]

type PairFunc2

type PairFunc2[A1, A2, R1, R2 any] func(A1, A2) (R1, R2)

func MakePairFunc2

func MakePairFunc2[A1, A2, R1, R2 any, F ~func(A1, A2) (R1, R2)](f F) PairFunc2[A1, A2, R1, R2]

func (PairFunc2[A1, A2, R1, R2]) Call

func (f PairFunc2[A1, A2, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (PairFunc2[A1, A2, R1, R2]) Exec

func (f PairFunc2[A1, A2, R1, R2]) Exec(a1 A1, a2 A2) (r1 R1, r2 R2)

func (PairFunc2[A1, A2, R1, R2]) Invoke

func (f PairFunc2[A1, A2, R1, R2]) Invoke(a1 A1, a2 A2) (r1 R1, r2 R2, panicErr error)

func (PairFunc2[A1, A2, R1, R2]) ToDelegate

func (f PairFunc2[A1, A2, R1, R2]) ToDelegate() DelegatePairFunc2[A1, A2, R1, R2]

type PairFunc3

type PairFunc3[A1, A2, A3, R1, R2 any] func(A1, A2, A3) (R1, R2)

func MakePairFunc3

func MakePairFunc3[A1, A2, A3, R1, R2 any, F ~func(A1, A2, A3) (R1, R2)](f F) PairFunc3[A1, A2, A3, R1, R2]

func (PairFunc3[A1, A2, A3, R1, R2]) Call

func (f PairFunc3[A1, A2, A3, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (PairFunc3[A1, A2, A3, R1, R2]) Exec

func (f PairFunc3[A1, A2, A3, R1, R2]) Exec(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2)

func (PairFunc3[A1, A2, A3, R1, R2]) Invoke

func (f PairFunc3[A1, A2, A3, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3) (r1 R1, r2 R2, panicErr error)

func (PairFunc3[A1, A2, A3, R1, R2]) ToDelegate

func (f PairFunc3[A1, A2, A3, R1, R2]) ToDelegate() DelegatePairFunc3[A1, A2, A3, R1, R2]

type PairFunc4

type PairFunc4[A1, A2, A3, A4, R1, R2 any] func(A1, A2, A3, A4) (R1, R2)

func MakePairFunc4

func MakePairFunc4[A1, A2, A3, A4, R1, R2 any, F ~func(A1, A2, A3, A4) (R1, R2)](f F) PairFunc4[A1, A2, A3, A4, R1, R2]

func (PairFunc4[A1, A2, A3, A4, R1, R2]) Call

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (PairFunc4[A1, A2, A3, A4, R1, R2]) Exec

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2)

func (PairFunc4[A1, A2, A3, A4, R1, R2]) Invoke

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4) (r1 R1, r2 R2, panicErr error)

func (PairFunc4[A1, A2, A3, A4, R1, R2]) ToDelegate

func (f PairFunc4[A1, A2, A3, A4, R1, R2]) ToDelegate() DelegatePairFunc4[A1, A2, A3, A4, R1, R2]

type PairFunc5

type PairFunc5[A1, A2, A3, A4, A5, R1, R2 any] func(
	A1, A2, A3, A4, A5,
) (R1, R2)

func MakePairFunc5

func MakePairFunc5[A1, A2, A3, A4, A5, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5,
) (R1, R2)](f F) PairFunc5[A1, A2, A3, A4, A5, R1, R2]

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2)

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate

func (f PairFunc5[A1, A2, A3, A4, A5, R1, R2]) ToDelegate() DelegatePairFunc5[A1, A2, A3, A4, A5, R1, R2]

type PairFunc6

type PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)

func MakePairFunc6

func MakePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6,
) (R1, R2)](f F) PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2)

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate

func (f PairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]) ToDelegate() DelegatePairFunc6[A1, A2, A3, A4, A5, A6, R1, R2]

type PairFunc7

type PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)

func MakePairFunc7

func MakePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7,
) (R1, R2)](f F) PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2)

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate

func (f PairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]) ToDelegate() DelegatePairFunc7[A1, A2, A3, A4, A5, A6, A7, R1, R2]

type PairFunc8

type PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)

func MakePairFunc8

func MakePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8,
) (R1, R2)](f F) PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2)

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate

func (f PairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]) ToDelegate() DelegatePairFunc8[A1, A2, A3, A4, A5, A6, A7, A8, R1, R2]

type PairFunc9

type PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)

func MakePairFunc9

func MakePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9,
) (R1, R2)](f F) PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2)

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9,
) (r1 R1, r2 R2, panicErr error)

func (PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate

func (f PairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]) ToDelegate() DelegatePairFunc9[A1, A2, A3, A4, A5, A6, A7, A8, A9, R1, R2]

type PairFuncVar0

type PairFuncVar0[VA, R1, R2 any] func(...VA) (R1, R2)

func MakePairFuncVar0

func MakePairFuncVar0[VA, R1, R2 any, F ~func(...VA) (R1, R2)](f F) PairFuncVar0[VA, R1, R2]

func (PairFuncVar0[VA, R1, R2]) Call

func (f PairFuncVar0[VA, R1, R2]) Call(autoRecover bool, reportError chan error, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar0[VA, R1, R2]) Exec

func (f PairFuncVar0[VA, R1, R2]) Exec(args ...VA) (r1 R1, r2 R2)

func (PairFuncVar0[VA, R1, R2]) Invoke

func (f PairFuncVar0[VA, R1, R2]) Invoke(args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar0[VA, R1, R2]) ToDelegate

func (f PairFuncVar0[VA, R1, R2]) ToDelegate() DelegatePairFuncVar0[VA, R1, R2]

type PairFuncVar1

type PairFuncVar1[A1, VA, R1, R2 any] func(A1, ...VA) (R1, R2)

func MakePairFuncVar1

func MakePairFuncVar1[A1, VA, R1, R2 any, F ~func(A1, ...VA) (R1, R2)](f F) PairFuncVar1[A1, VA, R1, R2]

func (PairFuncVar1[A1, VA, R1, R2]) Call

func (f PairFuncVar1[A1, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar1[A1, VA, R1, R2]) Exec

func (f PairFuncVar1[A1, VA, R1, R2]) Exec(a1 A1, args ...VA) (r1 R1, r2 R2)

func (PairFuncVar1[A1, VA, R1, R2]) Invoke

func (f PairFuncVar1[A1, VA, R1, R2]) Invoke(a1 A1, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar1[A1, VA, R1, R2]) ToDelegate

func (f PairFuncVar1[A1, VA, R1, R2]) ToDelegate() DelegatePairFuncVar1[A1, VA, R1, R2]

type PairFuncVar10

type PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)

func MakePairFuncVar10

func MakePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, ...VA,
) (R1, R2)](f F) PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate

func (f PairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]) ToDelegate() DelegatePairFuncVar10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, VA, R1, R2]

type PairFuncVar11

type PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)

func MakePairFuncVar11

func MakePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, ...VA,
) (R1, R2)](f F) PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate

func (f PairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]) ToDelegate() DelegatePairFuncVar11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, VA, R1, R2]

type PairFuncVar12

type PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)

func MakePairFuncVar12

func MakePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, ...VA,
) (R1, R2)](f F) PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate

func (f PairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]) ToDelegate() DelegatePairFuncVar12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, VA, R1, R2]

type PairFuncVar13

type PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)

func MakePairFuncVar13

func MakePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, ...VA,
) (R1, R2)](f F) PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate

func (f PairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]) ToDelegate() DelegatePairFuncVar13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, VA, R1, R2]

type PairFuncVar14

type PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)

func MakePairFuncVar14

func MakePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, ...VA,
) (R1, R2)](f F) PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate

func (f PairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]) ToDelegate() DelegatePairFuncVar14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, VA, R1, R2]

type PairFuncVar15

type PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)

func MakePairFuncVar15

func MakePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, ...VA,
) (R1, R2)](f F) PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate

func (f PairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]) ToDelegate() DelegatePairFuncVar15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, VA, R1, R2]

type PairFuncVar16

type PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)

func MakePairFuncVar16

func MakePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, ...VA,
) (R1, R2)](f F) PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, a10 A10, a11 A11, a12 A12, a13 A13, a14 A14, a15 A15, a16 A16, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate

func (f PairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]) ToDelegate() DelegatePairFuncVar16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, VA, R1, R2]

type PairFuncVar2

type PairFuncVar2[A1, A2, VA, R1, R2 any] func(A1, A2, ...VA) (R1, R2)

func MakePairFuncVar2

func MakePairFuncVar2[A1, A2, VA, R1, R2 any, F ~func(A1, A2, ...VA) (R1, R2)](f F) PairFuncVar2[A1, A2, VA, R1, R2]

func (PairFuncVar2[A1, A2, VA, R1, R2]) Call

func (f PairFuncVar2[A1, A2, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar2[A1, A2, VA, R1, R2]) Exec

func (f PairFuncVar2[A1, A2, VA, R1, R2]) Exec(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2)

func (PairFuncVar2[A1, A2, VA, R1, R2]) Invoke

func (f PairFuncVar2[A1, A2, VA, R1, R2]) Invoke(a1 A1, a2 A2, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar2[A1, A2, VA, R1, R2]) ToDelegate

func (f PairFuncVar2[A1, A2, VA, R1, R2]) ToDelegate() DelegatePairFuncVar2[A1, A2, VA, R1, R2]

type PairFuncVar3

type PairFuncVar3[A1, A2, A3, VA, R1, R2 any] func(A1, A2, A3, ...VA) (R1, R2)

func MakePairFuncVar3

func MakePairFuncVar3[A1, A2, A3, VA, R1, R2 any, F ~func(A1, A2, A3, ...VA) (R1, R2)](f F) PairFuncVar3[A1, A2, A3, VA, R1, R2]

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) Call

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2)

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar3[A1, A2, A3, VA, R1, R2]) ToDelegate

func (f PairFuncVar3[A1, A2, A3, VA, R1, R2]) ToDelegate() DelegatePairFuncVar3[A1, A2, A3, VA, R1, R2]

type PairFuncVar4

type PairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any] func(A1, A2, A3, A4, ...VA) (R1, R2)

func MakePairFuncVar4

func MakePairFuncVar4[A1, A2, A3, A4, VA, R1, R2 any, F ~func(A1, A2, A3, A4, ...VA) (R1, R2)](f F) PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Call(autoRecover bool, reportError chan error, a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Exec(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2)

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) Invoke(a1 A1, a2 A2, a3 A3, a4 A4, args ...VA) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate

func (f PairFuncVar4[A1, A2, A3, A4, VA, R1, R2]) ToDelegate() DelegatePairFuncVar4[A1, A2, A3, A4, VA, R1, R2]

type PairFuncVar5

type PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)

func MakePairFuncVar5

func MakePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, ...VA,
) (R1, R2)](f F) PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate

func (f PairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]) ToDelegate() DelegatePairFuncVar5[A1, A2, A3, A4, A5, VA, R1, R2]

type PairFuncVar6

type PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)

func MakePairFuncVar6

func MakePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, ...VA,
) (R1, R2)](f F) PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate

func (f PairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]) ToDelegate() DelegatePairFuncVar6[A1, A2, A3, A4, A5, A6, VA, R1, R2]

type PairFuncVar7

type PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)

func MakePairFuncVar7

func MakePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, ...VA,
) (R1, R2)](f F) PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate

func (f PairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]) ToDelegate() DelegatePairFuncVar7[A1, A2, A3, A4, A5, A6, A7, VA, R1, R2]

type PairFuncVar8

type PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)

func MakePairFuncVar8

func MakePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, ...VA,
) (R1, R2)](f F) PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate

func (f PairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]) ToDelegate() DelegatePairFuncVar8[A1, A2, A3, A4, A5, A6, A7, A8, VA, R1, R2]

type PairFuncVar9

type PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any] func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)

func MakePairFuncVar9

func MakePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2 any, F ~func(
	A1, A2, A3, A4, A5, A6, A7, A8, A9, ...VA,
) (R1, R2)](f F) PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Call(
	autoRecover bool, reportError chan error,
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Exec(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2)

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) Invoke(
	a1 A1, a2 A2, a3 A3, a4 A4, a5 A5, a6 A6, a7 A7, a8 A8, a9 A9, args ...VA,
) (r1 R1, r2 R2, panicErr error)

func (PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate

func (f PairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]) ToDelegate() DelegatePairFuncVar9[A1, A2, A3, A4, A5, A6, A7, A8, A9, VA, R1, R2]

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]) 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]) 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