tuplefunc

package
v0.0.0-...-97ebcb8 Latest Latest
Warning

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

 Go to latest Published: Mar 19, 2023 License: Apache-2.0, BSD-3-Clause Imports: 2 Imported by: 0

Documentation

Overview

Package tuplefunc provides functions that convert between multiple-argument and multiple-return functions and single-argument, single-return functions. This makes it trivial to pass arbitrary functions to generic operations that are designed to operate on arbitrary functions.

For functions with as many argument or return parameters as can be represented by the tuple package, this package provides a function to convert to and from those forms.

The names of most functions in this package match the following regular expression: 

ToC?A?R?E?_[0-9]+(_[0-9]+)?

Each optional letter represents one aspect of the function that's being converted to. 

C - context.Context argument
A - argument parameter
R - return parameter
E - error return

When there are both argument and return parameters (both A and R are present), the first number holds the number of argument parameters (not including context.Context for a C function) and the second holds the number of return parameters (not including error for an E function).

For a function form that can never include argument parameters (no A is present), there's only a single number holding the number of return parameters.

For a function form that can never include return parameters (no R is present), there's only a single number holding the number of argument parameters.

So, for example: 

ToCRE_1_3

converts from (for some types A, R0, R1 and R2) 

func(context.Context, A) (R0, R1, R2, error)

to: 

func(context.Context, A) (tuple.T3[R0, R1, R2], error)

Note that the same function could also be converted with: 

ToAR_2_4

with resulting signature: 

func(tuple.T2[context.Context, A]) tuple.T4[R0, R1, R2, error]

Another example: 

ToA_2

converts from (for some types A0, A1) 

func(A0, A1)

to: 

func(tuple.T2[A0, A1])

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ToAE_0 

func ToAE_0(f func() error) func(tuple.T0) error

ToAE_0 returns a single-argument function that calls f.

func ToAE_2 

func ToAE_2[A0, A1 any](f func(a0 A0, a1 A1) error) func(tuple.T2[A0, A1]) error

ToAE_2 returns a single-argument function that calls f.

func ToAE_3 

func ToAE_3[A0, A1, A2 any](f func(a0 A0, a1 A1, a2 A2) error) func(tuple.T3[A0, A1, A2]) error

ToAE_3 returns a single-argument function that calls f.

func ToAE_4 

func ToAE_4[A0, A1, A2, A3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) error) func(tuple.T4[A0, A1, A2, A3]) error

ToAE_4 returns a single-argument function that calls f.

func ToAE_5 

func ToAE_5[A0, A1, A2, A3, A4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) error) func(tuple.T5[A0, A1, A2, A3, A4]) error

ToAE_5 returns a single-argument function that calls f.

func ToAE_6 

func ToAE_6[A0, A1, A2, A3, A4, A5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) error) func(tuple.T6[A0, A1, A2, A3, A4, A5]) error

ToAE_6 returns a single-argument function that calls f.

func ToARE_0_0 

func ToARE_0_0(f func() error) func(tuple.T0) (tuple.T0, error)

ToARE_0_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_0_1 

func ToARE_0_1[R any](f func() (R, error)) func(tuple.T0) (R, error)

ToARE_0_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_0_2 

func ToARE_0_2[R0, R1 any](f func() (R0, R1, error)) func(tuple.T0) (tuple.T2[R0, R1], error)

ToARE_0_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_0_3 

func ToARE_0_3[R0, R1, R2 any](f func() (R0, R1, R2, error)) func(tuple.T0) (tuple.T3[R0, R1, R2], error)

ToARE_0_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_0_4 

func ToARE_0_4[R0, R1, R2, R3 any](f func() (R0, R1, R2, R3, error)) func(tuple.T0) (tuple.T4[R0, R1, R2, R3], error)

ToARE_0_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_0_5 

func ToARE_0_5[R0, R1, R2, R3, R4 any](f func() (R0, R1, R2, R3, R4, error)) func(tuple.T0) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_0_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_0_6 

func ToARE_0_6[R0, R1, R2, R3, R4, R5 any](f func() (R0, R1, R2, R3, R4, R5, error)) func(tuple.T0) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_0_6 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_0 

func ToARE_1_0[A any](f func(a A) error) func(A) (tuple.T0, error)

ToARE_1_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_1 

func ToARE_1_1[A, R any](f func(a A) (R, error)) func(A) (R, error)

ToARE_1_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_2 

func ToARE_1_2[A, R0, R1 any](f func(a A) (R0, R1, error)) func(A) (tuple.T2[R0, R1], error)

ToARE_1_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_3 

func ToARE_1_3[A, R0, R1, R2 any](f func(a A) (R0, R1, R2, error)) func(A) (tuple.T3[R0, R1, R2], error)

ToARE_1_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_4 

func ToARE_1_4[A, R0, R1, R2, R3 any](f func(a A) (R0, R1, R2, R3, error)) func(A) (tuple.T4[R0, R1, R2, R3], error)

ToARE_1_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_5 

func ToARE_1_5[A, R0, R1, R2, R3, R4 any](f func(a A) (R0, R1, R2, R3, R4, error)) func(A) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_1_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_1_6 

func ToARE_1_6[A, R0, R1, R2, R3, R4, R5 any](f func(a A) (R0, R1, R2, R3, R4, R5, error)) func(A) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_1_6 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_0 

func ToARE_2_0[A0, A1 any](f func(a0 A0, a1 A1) error) func(tuple.T2[A0, A1]) (tuple.T0, error)

ToARE_2_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_1 

func ToARE_2_1[A0, A1, R any](f func(a0 A0, a1 A1) (R, error)) func(tuple.T2[A0, A1]) (R, error)

ToARE_2_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_2 

func ToARE_2_2[A0, A1, R0, R1 any](f func(a0 A0, a1 A1) (R0, R1, error)) func(tuple.T2[A0, A1]) (tuple.T2[R0, R1], error)

ToARE_2_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_3 

func ToARE_2_3[A0, A1, R0, R1, R2 any](f func(a0 A0, a1 A1) (R0, R1, R2, error)) func(tuple.T2[A0, A1]) (tuple.T3[R0, R1, R2], error)

ToARE_2_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_4 

func ToARE_2_4[A0, A1, R0, R1, R2, R3 any](f func(a0 A0, a1 A1) (R0, R1, R2, R3, error)) func(tuple.T2[A0, A1]) (tuple.T4[R0, R1, R2, R3], error)

ToARE_2_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_5 

func ToARE_2_5[A0, A1, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1) (R0, R1, R2, R3, R4, error)) func(tuple.T2[A0, A1]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_2_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_2_6 

func ToARE_2_6[A0, A1, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1) (R0, R1, R2, R3, R4, R5, error)) func(tuple.T2[A0, A1]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_2_6 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_0 

func ToARE_3_0[A0, A1, A2 any](f func(a0 A0, a1 A1, a2 A2) error) func(tuple.T3[A0, A1, A2]) (tuple.T0, error)

ToARE_3_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_1 

func ToARE_3_1[A0, A1, A2, R any](f func(a0 A0, a1 A1, a2 A2) (R, error)) func(tuple.T3[A0, A1, A2]) (R, error)

ToARE_3_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_2 

func ToARE_3_2[A0, A1, A2, R0, R1 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, error)) func(tuple.T3[A0, A1, A2]) (tuple.T2[R0, R1], error)

ToARE_3_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_3 

func ToARE_3_3[A0, A1, A2, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, error)) func(tuple.T3[A0, A1, A2]) (tuple.T3[R0, R1, R2], error)

ToARE_3_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_4 

func ToARE_3_4[A0, A1, A2, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, error)) func(tuple.T3[A0, A1, A2]) (tuple.T4[R0, R1, R2, R3], error)

ToARE_3_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_5 

func ToARE_3_5[A0, A1, A2, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, R4, error)) func(tuple.T3[A0, A1, A2]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_3_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_3_6 

func ToARE_3_6[A0, A1, A2, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, R4, R5, error)) func(tuple.T3[A0, A1, A2]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_3_6 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_0 

func ToARE_4_0[A0, A1, A2, A3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) error) func(tuple.T4[A0, A1, A2, A3]) (tuple.T0, error)

ToARE_4_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_1 

func ToARE_4_1[A0, A1, A2, A3, R any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R, error)) func(tuple.T4[A0, A1, A2, A3]) (R, error)

ToARE_4_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_2 

func ToARE_4_2[A0, A1, A2, A3, R0, R1 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, error)) func(tuple.T4[A0, A1, A2, A3]) (tuple.T2[R0, R1], error)

ToARE_4_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_3 

func ToARE_4_3[A0, A1, A2, A3, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, error)) func(tuple.T4[A0, A1, A2, A3]) (tuple.T3[R0, R1, R2], error)

ToARE_4_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_4 

func ToARE_4_4[A0, A1, A2, A3, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, error)) func(tuple.T4[A0, A1, A2, A3]) (tuple.T4[R0, R1, R2, R3], error)

ToARE_4_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_5 

func ToARE_4_5[A0, A1, A2, A3, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, R4, error)) func(tuple.T4[A0, A1, A2, A3]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_4_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_4_6 

func ToARE_4_6[A0, A1, A2, A3, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, R4, R5, error)) func(tuple.T4[A0, A1, A2, A3]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_4_6 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_0 

func ToARE_5_0[A0, A1, A2, A3, A4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) error) func(tuple.T5[A0, A1, A2, A3, A4]) (tuple.T0, error)

ToARE_5_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_1 

func ToARE_5_1[A0, A1, A2, A3, A4, R any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R, error)) func(tuple.T5[A0, A1, A2, A3, A4]) (R, error)

ToARE_5_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_2 

func ToARE_5_2[A0, A1, A2, A3, A4, R0, R1 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, error)) func(tuple.T5[A0, A1, A2, A3, A4]) (tuple.T2[R0, R1], error)

ToARE_5_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_3 

func ToARE_5_3[A0, A1, A2, A3, A4, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, error)) func(tuple.T5[A0, A1, A2, A3, A4]) (tuple.T3[R0, R1, R2], error)

ToARE_5_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_4 

func ToARE_5_4[A0, A1, A2, A3, A4, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, error)) func(tuple.T5[A0, A1, A2, A3, A4]) (tuple.T4[R0, R1, R2, R3], error)

ToARE_5_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_5 

func ToARE_5_5[A0, A1, A2, A3, A4, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, R4, error)) func(tuple.T5[A0, A1, A2, A3, A4]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_5_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_5_6 

func ToARE_5_6[A0, A1, A2, A3, A4, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, R4, R5, error)) func(tuple.T5[A0, A1, A2, A3, A4]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_5_6 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_0 

func ToARE_6_0[A0, A1, A2, A3, A4, A5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) error) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T0, error)

ToARE_6_0 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_1 

func ToARE_6_1[A0, A1, A2, A3, A4, A5, R any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R, error)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (R, error)

ToARE_6_1 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_2 

func ToARE_6_2[A0, A1, A2, A3, A4, A5, R0, R1 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, error)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T2[R0, R1], error)

ToARE_6_2 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_3 

func ToARE_6_3[A0, A1, A2, A3, A4, A5, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, error)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T3[R0, R1, R2], error)

ToARE_6_3 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_4 

func ToARE_6_4[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, error)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T4[R0, R1, R2, R3], error)

ToARE_6_4 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_5 

func ToARE_6_5[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, R4, error)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToARE_6_5 returns a single-argument, single-return-with-error function that calls f.

func ToARE_6_6 

func ToARE_6_6[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, R4, R5, error)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToARE_6_6 returns a single-argument, single-return-with-error function that calls f.

func ToAR_0_0 

func ToAR_0_0(f func()) func(tuple.T0) tuple.T0

ToAR_0_0 returns a single-argument, single-return function that calls f.

func ToAR_0_1 

func ToAR_0_1[R any](f func() R) func(tuple.T0) R

ToAR_0_1 returns a single-argument, single-return function that calls f.

func ToAR_0_2 

func ToAR_0_2[R0, R1 any](f func() (R0, R1)) func(tuple.T0) tuple.T2[R0, R1]

ToAR_0_2 returns a single-argument, single-return function that calls f.

func ToAR_0_3 

func ToAR_0_3[R0, R1, R2 any](f func() (R0, R1, R2)) func(tuple.T0) tuple.T3[R0, R1, R2]

ToAR_0_3 returns a single-argument, single-return function that calls f.

func ToAR_0_4 

func ToAR_0_4[R0, R1, R2, R3 any](f func() (R0, R1, R2, R3)) func(tuple.T0) tuple.T4[R0, R1, R2, R3]

ToAR_0_4 returns a single-argument, single-return function that calls f.

func ToAR_0_5 

func ToAR_0_5[R0, R1, R2, R3, R4 any](f func() (R0, R1, R2, R3, R4)) func(tuple.T0) tuple.T5[R0, R1, R2, R3, R4]

ToAR_0_5 returns a single-argument, single-return function that calls f.

func ToAR_0_6 

func ToAR_0_6[R0, R1, R2, R3, R4, R5 any](f func() (R0, R1, R2, R3, R4, R5)) func(tuple.T0) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_0_6 returns a single-argument, single-return function that calls f.

func ToAR_1_0 

func ToAR_1_0[A any](f func(a A)) func(A) tuple.T0

ToAR_1_0 returns a single-argument, single-return function that calls f.

func ToAR_1_1 

func ToAR_1_1[A, R any](f func(a A) R) func(A) R

ToAR_1_1 returns a single-argument, single-return function that calls f.

func ToAR_1_2 

func ToAR_1_2[A, R0, R1 any](f func(a A) (R0, R1)) func(A) tuple.T2[R0, R1]

ToAR_1_2 returns a single-argument, single-return function that calls f.

func ToAR_1_3 

func ToAR_1_3[A, R0, R1, R2 any](f func(a A) (R0, R1, R2)) func(A) tuple.T3[R0, R1, R2]

ToAR_1_3 returns a single-argument, single-return function that calls f.

func ToAR_1_4 

func ToAR_1_4[A, R0, R1, R2, R3 any](f func(a A) (R0, R1, R2, R3)) func(A) tuple.T4[R0, R1, R2, R3]

ToAR_1_4 returns a single-argument, single-return function that calls f.

func ToAR_1_5 

func ToAR_1_5[A, R0, R1, R2, R3, R4 any](f func(a A) (R0, R1, R2, R3, R4)) func(A) tuple.T5[R0, R1, R2, R3, R4]

ToAR_1_5 returns a single-argument, single-return function that calls f.

func ToAR_1_6 

func ToAR_1_6[A, R0, R1, R2, R3, R4, R5 any](f func(a A) (R0, R1, R2, R3, R4, R5)) func(A) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_1_6 returns a single-argument, single-return function that calls f.

func ToAR_2_0 

func ToAR_2_0[A0, A1 any](f func(a0 A0, a1 A1)) func(tuple.T2[A0, A1]) tuple.T0

ToAR_2_0 returns a single-argument, single-return function that calls f.

func ToAR_2_1 

func ToAR_2_1[A0, A1, R any](f func(a0 A0, a1 A1) R) func(tuple.T2[A0, A1]) R

ToAR_2_1 returns a single-argument, single-return function that calls f.

func ToAR_2_2 

func ToAR_2_2[A0, A1, R0, R1 any](f func(a0 A0, a1 A1) (R0, R1)) func(tuple.T2[A0, A1]) tuple.T2[R0, R1]

ToAR_2_2 returns a single-argument, single-return function that calls f.

func ToAR_2_3 

func ToAR_2_3[A0, A1, R0, R1, R2 any](f func(a0 A0, a1 A1) (R0, R1, R2)) func(tuple.T2[A0, A1]) tuple.T3[R0, R1, R2]

ToAR_2_3 returns a single-argument, single-return function that calls f.

func ToAR_2_4 

func ToAR_2_4[A0, A1, R0, R1, R2, R3 any](f func(a0 A0, a1 A1) (R0, R1, R2, R3)) func(tuple.T2[A0, A1]) tuple.T4[R0, R1, R2, R3]

ToAR_2_4 returns a single-argument, single-return function that calls f.

func ToAR_2_5 

func ToAR_2_5[A0, A1, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1) (R0, R1, R2, R3, R4)) func(tuple.T2[A0, A1]) tuple.T5[R0, R1, R2, R3, R4]

ToAR_2_5 returns a single-argument, single-return function that calls f.

func ToAR_2_6 

func ToAR_2_6[A0, A1, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1) (R0, R1, R2, R3, R4, R5)) func(tuple.T2[A0, A1]) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_2_6 returns a single-argument, single-return function that calls f.

func ToAR_3_0 

func ToAR_3_0[A0, A1, A2 any](f func(a0 A0, a1 A1, a2 A2)) func(tuple.T3[A0, A1, A2]) tuple.T0

ToAR_3_0 returns a single-argument, single-return function that calls f.

func ToAR_3_1 

func ToAR_3_1[A0, A1, A2, R any](f func(a0 A0, a1 A1, a2 A2) R) func(tuple.T3[A0, A1, A2]) R

ToAR_3_1 returns a single-argument, single-return function that calls f.

func ToAR_3_2 

func ToAR_3_2[A0, A1, A2, R0, R1 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1)) func(tuple.T3[A0, A1, A2]) tuple.T2[R0, R1]

ToAR_3_2 returns a single-argument, single-return function that calls f.

func ToAR_3_3 

func ToAR_3_3[A0, A1, A2, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2)) func(tuple.T3[A0, A1, A2]) tuple.T3[R0, R1, R2]

ToAR_3_3 returns a single-argument, single-return function that calls f.

func ToAR_3_4 

func ToAR_3_4[A0, A1, A2, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3)) func(tuple.T3[A0, A1, A2]) tuple.T4[R0, R1, R2, R3]

ToAR_3_4 returns a single-argument, single-return function that calls f.

func ToAR_3_5 

func ToAR_3_5[A0, A1, A2, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, R4)) func(tuple.T3[A0, A1, A2]) tuple.T5[R0, R1, R2, R3, R4]

ToAR_3_5 returns a single-argument, single-return function that calls f.

func ToAR_3_6 

func ToAR_3_6[A0, A1, A2, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, R4, R5)) func(tuple.T3[A0, A1, A2]) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_3_6 returns a single-argument, single-return function that calls f.

func ToAR_4_0 

func ToAR_4_0[A0, A1, A2, A3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3)) func(tuple.T4[A0, A1, A2, A3]) tuple.T0

ToAR_4_0 returns a single-argument, single-return function that calls f.

func ToAR_4_1 

func ToAR_4_1[A0, A1, A2, A3, R any](f func(a0 A0, a1 A1, a2 A2, a3 A3) R) func(tuple.T4[A0, A1, A2, A3]) R

ToAR_4_1 returns a single-argument, single-return function that calls f.

func ToAR_4_2 

func ToAR_4_2[A0, A1, A2, A3, R0, R1 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1)) func(tuple.T4[A0, A1, A2, A3]) tuple.T2[R0, R1]

ToAR_4_2 returns a single-argument, single-return function that calls f.

func ToAR_4_3 

func ToAR_4_3[A0, A1, A2, A3, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2)) func(tuple.T4[A0, A1, A2, A3]) tuple.T3[R0, R1, R2]

ToAR_4_3 returns a single-argument, single-return function that calls f.

func ToAR_4_4 

func ToAR_4_4[A0, A1, A2, A3, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3)) func(tuple.T4[A0, A1, A2, A3]) tuple.T4[R0, R1, R2, R3]

ToAR_4_4 returns a single-argument, single-return function that calls f.

func ToAR_4_5 

func ToAR_4_5[A0, A1, A2, A3, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, R4)) func(tuple.T4[A0, A1, A2, A3]) tuple.T5[R0, R1, R2, R3, R4]

ToAR_4_5 returns a single-argument, single-return function that calls f.

func ToAR_4_6 

func ToAR_4_6[A0, A1, A2, A3, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, R4, R5)) func(tuple.T4[A0, A1, A2, A3]) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_4_6 returns a single-argument, single-return function that calls f.

func ToAR_5_0 

func ToAR_5_0[A0, A1, A2, A3, A4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4)) func(tuple.T5[A0, A1, A2, A3, A4]) tuple.T0

ToAR_5_0 returns a single-argument, single-return function that calls f.

func ToAR_5_1 

func ToAR_5_1[A0, A1, A2, A3, A4, R any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) R) func(tuple.T5[A0, A1, A2, A3, A4]) R

ToAR_5_1 returns a single-argument, single-return function that calls f.

func ToAR_5_2 

func ToAR_5_2[A0, A1, A2, A3, A4, R0, R1 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1)) func(tuple.T5[A0, A1, A2, A3, A4]) tuple.T2[R0, R1]

ToAR_5_2 returns a single-argument, single-return function that calls f.

func ToAR_5_3 

func ToAR_5_3[A0, A1, A2, A3, A4, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2)) func(tuple.T5[A0, A1, A2, A3, A4]) tuple.T3[R0, R1, R2]

ToAR_5_3 returns a single-argument, single-return function that calls f.

func ToAR_5_4 

func ToAR_5_4[A0, A1, A2, A3, A4, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3)) func(tuple.T5[A0, A1, A2, A3, A4]) tuple.T4[R0, R1, R2, R3]

ToAR_5_4 returns a single-argument, single-return function that calls f.

func ToAR_5_5 

func ToAR_5_5[A0, A1, A2, A3, A4, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, R4)) func(tuple.T5[A0, A1, A2, A3, A4]) tuple.T5[R0, R1, R2, R3, R4]

ToAR_5_5 returns a single-argument, single-return function that calls f.

func ToAR_5_6 

func ToAR_5_6[A0, A1, A2, A3, A4, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, R4, R5)) func(tuple.T5[A0, A1, A2, A3, A4]) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_5_6 returns a single-argument, single-return function that calls f.

func ToAR_6_0 

func ToAR_6_0[A0, A1, A2, A3, A4, A5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) tuple.T0

ToAR_6_0 returns a single-argument, single-return function that calls f.

func ToAR_6_1 

func ToAR_6_1[A0, A1, A2, A3, A4, A5, R any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) R) func(tuple.T6[A0, A1, A2, A3, A4, A5]) R

ToAR_6_1 returns a single-argument, single-return function that calls f.

func ToAR_6_2 

func ToAR_6_2[A0, A1, A2, A3, A4, A5, R0, R1 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) tuple.T2[R0, R1]

ToAR_6_2 returns a single-argument, single-return function that calls f.

func ToAR_6_3 

func ToAR_6_3[A0, A1, A2, A3, A4, A5, R0, R1, R2 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) tuple.T3[R0, R1, R2]

ToAR_6_3 returns a single-argument, single-return function that calls f.

func ToAR_6_4 

func ToAR_6_4[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) tuple.T4[R0, R1, R2, R3]

ToAR_6_4 returns a single-argument, single-return function that calls f.

func ToAR_6_5 

func ToAR_6_5[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3, R4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, R4)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) tuple.T5[R0, R1, R2, R3, R4]

ToAR_6_5 returns a single-argument, single-return function that calls f.

func ToAR_6_6 

func ToAR_6_6[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3, R4, R5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, R4, R5)) func(tuple.T6[A0, A1, A2, A3, A4, A5]) tuple.T6[R0, R1, R2, R3, R4, R5]

ToAR_6_6 returns a single-argument, single-return function that calls f.

func ToA_0 

func ToA_0(f func()) func(tuple.T0)

ToA_0 returns a single-argument function that calls f.

func ToA_2 

func ToA_2[A0, A1 any](f func(a0 A0, a1 A1)) func(tuple.T2[A0, A1])

ToA_2 returns a single-argument function that calls f.

func ToA_3 

func ToA_3[A0, A1, A2 any](f func(a0 A0, a1 A1, a2 A2)) func(tuple.T3[A0, A1, A2])

ToA_3 returns a single-argument function that calls f.

func ToA_4 

func ToA_4[A0, A1, A2, A3 any](f func(a0 A0, a1 A1, a2 A2, a3 A3)) func(tuple.T4[A0, A1, A2, A3])

ToA_4 returns a single-argument function that calls f.

func ToA_5 

func ToA_5[A0, A1, A2, A3, A4 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4)) func(tuple.T5[A0, A1, A2, A3, A4])

ToA_5 returns a single-argument function that calls f.

func ToA_6 

func ToA_6[A0, A1, A2, A3, A4, A5 any](f func(a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5)) func(tuple.T6[A0, A1, A2, A3, A4, A5])

ToA_6 returns a single-argument function that calls f.

func ToCARE_0_0 

func ToCARE_0_0(f func(ctx context.Context) error) func(context.Context, tuple.T0) (tuple.T0, error)

ToCARE_0_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_0_1 

func ToCARE_0_1[R any](f func(ctx context.Context) (R, error)) func(context.Context, tuple.T0) (R, error)

ToCARE_0_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_0_2 

func ToCARE_0_2[R0, R1 any](f func(ctx context.Context) (R0, R1, error)) func(context.Context, tuple.T0) (tuple.T2[R0, R1], error)

ToCARE_0_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_0_3 

func ToCARE_0_3[R0, R1, R2 any](f func(ctx context.Context) (R0, R1, R2, error)) func(context.Context, tuple.T0) (tuple.T3[R0, R1, R2], error)

ToCARE_0_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_0_4 

func ToCARE_0_4[R0, R1, R2, R3 any](f func(ctx context.Context) (R0, R1, R2, R3, error)) func(context.Context, tuple.T0) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_0_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_0_5 

func ToCARE_0_5[R0, R1, R2, R3, R4 any](f func(ctx context.Context) (R0, R1, R2, R3, R4, error)) func(context.Context, tuple.T0) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_0_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_0_6 

func ToCARE_0_6[R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, tuple.T0) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_0_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_0 

func ToCARE_1_0[A any](f func(ctx context.Context, a A) error) func(context.Context, A) (tuple.T0, error)

ToCARE_1_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_1 

func ToCARE_1_1[A, R any](f func(ctx context.Context, a A) (R, error)) func(context.Context, A) (R, error)

ToCARE_1_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_2 

func ToCARE_1_2[A, R0, R1 any](f func(ctx context.Context, a A) (R0, R1, error)) func(context.Context, A) (tuple.T2[R0, R1], error)

ToCARE_1_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_3 

func ToCARE_1_3[A, R0, R1, R2 any](f func(ctx context.Context, a A) (R0, R1, R2, error)) func(context.Context, A) (tuple.T3[R0, R1, R2], error)

ToCARE_1_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_4 

func ToCARE_1_4[A, R0, R1, R2, R3 any](f func(ctx context.Context, a A) (R0, R1, R2, R3, error)) func(context.Context, A) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_1_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_5 

func ToCARE_1_5[A, R0, R1, R2, R3, R4 any](f func(ctx context.Context, a A) (R0, R1, R2, R3, R4, error)) func(context.Context, A) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_1_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_1_6 

func ToCARE_1_6[A, R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context, a A) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, A) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_1_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_0 

func ToCARE_2_0[A0, A1 any](f func(ctx context.Context, a0 A0, a1 A1) error) func(context.Context, tuple.T2[A0, A1]) (tuple.T0, error)

ToCARE_2_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_1 

func ToCARE_2_1[A0, A1, R any](f func(ctx context.Context, a0 A0, a1 A1) (R, error)) func(context.Context, tuple.T2[A0, A1]) (R, error)

ToCARE_2_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_2 

func ToCARE_2_2[A0, A1, R0, R1 any](f func(ctx context.Context, a0 A0, a1 A1) (R0, R1, error)) func(context.Context, tuple.T2[A0, A1]) (tuple.T2[R0, R1], error)

ToCARE_2_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_3 

func ToCARE_2_3[A0, A1, R0, R1, R2 any](f func(ctx context.Context, a0 A0, a1 A1) (R0, R1, R2, error)) func(context.Context, tuple.T2[A0, A1]) (tuple.T3[R0, R1, R2], error)

ToCARE_2_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_4 

func ToCARE_2_4[A0, A1, R0, R1, R2, R3 any](f func(ctx context.Context, a0 A0, a1 A1) (R0, R1, R2, R3, error)) func(context.Context, tuple.T2[A0, A1]) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_2_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_5 

func ToCARE_2_5[A0, A1, R0, R1, R2, R3, R4 any](f func(ctx context.Context, a0 A0, a1 A1) (R0, R1, R2, R3, R4, error)) func(context.Context, tuple.T2[A0, A1]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_2_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_2_6 

func ToCARE_2_6[A0, A1, R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context, a0 A0, a1 A1) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, tuple.T2[A0, A1]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_2_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_0 

func ToCARE_3_0[A0, A1, A2 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) error) func(context.Context, tuple.T3[A0, A1, A2]) (tuple.T0, error)

ToCARE_3_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_1 

func ToCARE_3_1[A0, A1, A2, R any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) (R, error)) func(context.Context, tuple.T3[A0, A1, A2]) (R, error)

ToCARE_3_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_2 

func ToCARE_3_2[A0, A1, A2, R0, R1 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) (R0, R1, error)) func(context.Context, tuple.T3[A0, A1, A2]) (tuple.T2[R0, R1], error)

ToCARE_3_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_3 

func ToCARE_3_3[A0, A1, A2, R0, R1, R2 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) (R0, R1, R2, error)) func(context.Context, tuple.T3[A0, A1, A2]) (tuple.T3[R0, R1, R2], error)

ToCARE_3_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_4 

func ToCARE_3_4[A0, A1, A2, R0, R1, R2, R3 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, error)) func(context.Context, tuple.T3[A0, A1, A2]) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_3_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_5 

func ToCARE_3_5[A0, A1, A2, R0, R1, R2, R3, R4 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, R4, error)) func(context.Context, tuple.T3[A0, A1, A2]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_3_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_3_6 

func ToCARE_3_6[A0, A1, A2, R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, tuple.T3[A0, A1, A2]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_3_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_0 

func ToCARE_4_0[A0, A1, A2, A3 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) error) func(context.Context, tuple.T4[A0, A1, A2, A3]) (tuple.T0, error)

ToCARE_4_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_1 

func ToCARE_4_1[A0, A1, A2, A3, R any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) (R, error)) func(context.Context, tuple.T4[A0, A1, A2, A3]) (R, error)

ToCARE_4_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_2 

func ToCARE_4_2[A0, A1, A2, A3, R0, R1 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, error)) func(context.Context, tuple.T4[A0, A1, A2, A3]) (tuple.T2[R0, R1], error)

ToCARE_4_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_3 

func ToCARE_4_3[A0, A1, A2, A3, R0, R1, R2 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, error)) func(context.Context, tuple.T4[A0, A1, A2, A3]) (tuple.T3[R0, R1, R2], error)

ToCARE_4_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_4 

func ToCARE_4_4[A0, A1, A2, A3, R0, R1, R2, R3 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, error)) func(context.Context, tuple.T4[A0, A1, A2, A3]) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_4_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_5 

func ToCARE_4_5[A0, A1, A2, A3, R0, R1, R2, R3, R4 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, R4, error)) func(context.Context, tuple.T4[A0, A1, A2, A3]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_4_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_4_6 

func ToCARE_4_6[A0, A1, A2, A3, R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, tuple.T4[A0, A1, A2, A3]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_4_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_0 

func ToCARE_5_0[A0, A1, A2, A3, A4 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) error) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (tuple.T0, error)

ToCARE_5_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_1 

func ToCARE_5_1[A0, A1, A2, A3, A4, R any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R, error)) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (R, error)

ToCARE_5_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_2 

func ToCARE_5_2[A0, A1, A2, A3, A4, R0, R1 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, error)) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (tuple.T2[R0, R1], error)

ToCARE_5_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_3 

func ToCARE_5_3[A0, A1, A2, A3, A4, R0, R1, R2 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, error)) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (tuple.T3[R0, R1, R2], error)

ToCARE_5_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_4 

func ToCARE_5_4[A0, A1, A2, A3, A4, R0, R1, R2, R3 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, error)) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_5_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_5 

func ToCARE_5_5[A0, A1, A2, A3, A4, R0, R1, R2, R3, R4 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, R4, error)) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_5_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_5_6 

func ToCARE_5_6[A0, A1, A2, A3, A4, R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, tuple.T5[A0, A1, A2, A3, A4]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_5_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_0 

func ToCARE_6_0[A0, A1, A2, A3, A4, A5 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) error) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T0, error)

ToCARE_6_0 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_1 

func ToCARE_6_1[A0, A1, A2, A3, A4, A5, R any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R, error)) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (R, error)

ToCARE_6_1 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_2 

func ToCARE_6_2[A0, A1, A2, A3, A4, A5, R0, R1 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, error)) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T2[R0, R1], error)

ToCARE_6_2 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_3 

func ToCARE_6_3[A0, A1, A2, A3, A4, A5, R0, R1, R2 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, error)) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T3[R0, R1, R2], error)

ToCARE_6_3 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_4 

func ToCARE_6_4[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, error)) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T4[R0, R1, R2, R3], error)

ToCARE_6_4 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_5 

func ToCARE_6_5[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3, R4 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, R4, error)) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T5[R0, R1, R2, R3, R4], error)

ToCARE_6_5 returns a context-with-single argument, single-return-with-error function that calls f.

func ToCARE_6_6 

func ToCARE_6_6[A0, A1, A2, A3, A4, A5, R0, R1, R2, R3, R4, R5 any](f func(ctx context.Context, a0 A0, a1 A1, a2 A2, a3 A3, a4 A4, a5 A5) (R0, R1, R2, R3, R4, R5, error)) func(context.Context, tuple.T6[A0, A1, A2, A3, A4, A5]) (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToCARE_6_6 returns a context-with-single argument, single-return-with-error function that calls f.

func ToRE_0 

func ToRE_0(f func() error) func() (tuple.T0, error)

ToRE_0 returns a single-return-with-error function that calls f.

func ToRE_2 

func ToRE_2[R0, R1 any](f func() (R0, R1, error)) func() (tuple.T2[R0, R1], error)

ToRE_2 returns a single-return-with-error function that calls f.

func ToRE_3 

func ToRE_3[R0, R1, R2 any](f func() (R0, R1, R2, error)) func() (tuple.T3[R0, R1, R2], error)

ToRE_3 returns a single-return-with-error function that calls f.

func ToRE_4 

func ToRE_4[R0, R1, R2, R3 any](f func() (R0, R1, R2, R3, error)) func() (tuple.T4[R0, R1, R2, R3], error)

ToRE_4 returns a single-return-with-error function that calls f.

func ToRE_5 

func ToRE_5[R0, R1, R2, R3, R4 any](f func() (R0, R1, R2, R3, R4, error)) func() (tuple.T5[R0, R1, R2, R3, R4], error)

ToRE_5 returns a single-return-with-error function that calls f.

func ToRE_6 

func ToRE_6[R0, R1, R2, R3, R4, R5 any](f func() (R0, R1, R2, R3, R4, R5, error)) func() (tuple.T6[R0, R1, R2, R3, R4, R5], error)

ToRE_6 returns a single-return-with-error function that calls f.

func ToR_0 

func ToR_0(f func()) func() tuple.T0

ToR_0 returns a single-return function that calls f.

func ToR_2 

func ToR_2[R0, R1 any](f func() (R0, R1)) func() tuple.T2[R0, R1]

ToR_2 returns a single-return function that calls f.

func ToR_3 

func ToR_3[R0, R1, R2 any](f func() (R0, R1, R2)) func() tuple.T3[R0, R1, R2]

ToR_3 returns a single-return function that calls f.

func ToR_4 

func ToR_4[R0, R1, R2, R3 any](f func() (R0, R1, R2, R3)) func() tuple.T4[R0, R1, R2, R3]

ToR_4 returns a single-return function that calls f.

func ToR_5 

func ToR_5[R0, R1, R2, R3, R4 any](f func() (R0, R1, R2, R3, R4)) func() tuple.T5[R0, R1, R2, R3, R4]

ToR_5 returns a single-return function that calls f.

func ToR_6 

func ToR_6[R0, R1, R2, R3, R4, R5 any](f func() (R0, R1, R2, R3, R4, R5)) func() tuple.T6[R0, R1, R2, R3, R4, R5]

ToR_6 returns a single-return function that calls f.

func WithContextA 

func WithContextA[A any](f func(A)) func(context.Context, A)

WithContext returns a function with a context argument that calls f without the context.

func WithContextAR 

func WithContextAR[A, R any](f func(A) R) func(context.Context, A) R

WithContextAR returns a function with a context argument that calls f without the context and returns its result.

func WithErrorAR 

func WithErrorAR[A, R any](f func(A) R) func(A) (R, error)

WithErrorAR returns an error-returning function that calls f and returns a nil error.

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.