diff --git a/go.mod b/go.mod
index f8a77d94..95d1b817 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/samber/lo
 
-go 1.18
+go 1.24
 
 //
 // Dev dependencies are excluded from releases. Please check CI.
@@ -9,8 +9,8 @@ go 1.18
 require (
 	github.com/stretchr/testify v1.10.0
 	github.com/thoas/go-funk v0.9.3
-	go.uber.org/goleak v1.2.1
-	golang.org/x/text v0.22.0
+	go.uber.org/goleak v1.3.0
+	golang.org/x/text v0.27.0
 )
 
 require (
diff --git a/go.sum b/go.sum
index 6b35edf0..4f6c6f50 100644
--- a/go.sum
+++ b/go.sum
@@ -18,8 +18,12 @@ github.com/thoas/go-funk v0.9.3 h1:7+nAEx3kn5ZJcnDm2Bh23N2yOtweO14bi//dvRtgLpw=
 github.com/thoas/go-funk v0.9.3/go.mod h1:+IWnUfUmFO1+WVYQWQtIJHeRRdaIyyYglZN7xzUPe4Q=
 go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
 go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
 golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/loany/func.go b/loany/func.go
new file mode 100644
index 00000000..3b32513b
--- /dev/null
+++ b/loany/func.go
@@ -0,0 +1,97 @@
+package loany
+
+import (
+	"fmt"
+	"github.com/samber/lo/loslice"
+	"reflect"
+)
+
+type argSource string
+
+const (
+	fromArgs   argSource = "args"
+	fromKwargs argSource = "kwargs"
+)
+
+func errCall(index int, value any, source argSource, fnType reflect.Type, kwType reflect.Type) error {
+	typeName := fnType.In(index).Name()
+	if kwType == nil {
+		return fmt.Errorf("expected argument #%d to be of type `%s`, got `%#v`", index+1, typeName, value)
+	}
+
+	argName := kwType.Field(index).Name
+	return fmt.Errorf("expected argument #%d (%s) to be of type `%s`, got from %s `%#v`", index+1, argName, typeName, source, value)
+}
+
+// Call calls a function with the provided args and kwargs.
+// Does not support variadic functions.
+// Does not panic on invalid input, but returns an error instead.
+func Call(fn any, args []any, kwargs any) ([]any, error) {
+	rvfn := reflect.ValueOf(fn)
+	rvkw := reflect.ValueOf(kwargs)
+
+	tfn := rvfn.Type()
+	if tfn.Kind() != reflect.Func {
+		return nil, fmt.Errorf("expected function, got `%#v`", fn)
+	}
+
+	if tfn.IsVariadic() {
+		return nil, fmt.Errorf("variadic functions are not supported, got `%#v`", fn)
+	}
+
+	numIn := tfn.NumIn()
+
+	if kwargs != nil {
+		if rvkw.Kind() == reflect.Pointer {
+			if rvkw.IsNil() {
+				return nil, fmt.Errorf("expected kwargs to be non-nil pointer, got %#v", kwargs)
+			}
+			rvkw = rvkw.Elem()
+		}
+
+		if rvkw.Kind() != reflect.Struct {
+			return nil, fmt.Errorf("expected kwargs to be struct, got `%#v`", kwargs)
+		}
+
+		if rvkw.NumField() != numIn {
+			return nil, fmt.Errorf("expected kwargs (`%T`) to have %d fields, got %d: %#v",
+				kwargs, numIn, rvkw.NumField(), kwargs)
+		}
+	} else if len(args) != numIn {
+		return nil, fmt.Errorf("no kwargs were provided, expected exactly %d args, got %d: %#v", numIn, len(args), args)
+	}
+
+	var (
+		val    any
+		source argSource
+	)
+
+	rvargs := make([]reflect.Value, numIn)
+
+	for i := range numIn {
+		if len(args) > 0 {
+			source = fromArgs
+			val = args[i]
+		} else if kwargs != nil {
+			source = fromKwargs
+			val = rvkw.Field(i).Interface()
+		} else {
+			panic("impossible: neither args nor kwargs were provided")
+		}
+
+		rv := reflect.ValueOf(val)
+		tin := tfn.In(i)
+
+		if !rv.CanConvert(tin) {
+			if kwargs == nil {
+				return nil, errCall(i, val, source, tfn, nil)
+			} else {
+				return nil, errCall(i, val, source, tfn, rvkw.Type())
+			}
+		}
+
+		rvargs[i] = rv.Convert(tin)
+	}
+
+	return loslice.Map(rvfn.Call(rvargs), reflect.Value.Interface), nil
+}
diff --git a/loany/map.go b/loany/map.go
new file mode 100644
index 00000000..128a12a5
--- /dev/null
+++ b/loany/map.go
@@ -0,0 +1,23 @@
+package loany
+
+func Map[Map ~map[K]V, K comparable, V any](m Map) map[K]any {
+	result := make(map[K]any, len(m))
+	for k, v := range m {
+		result[k] = v
+	}
+
+	return result
+}
+
+// TypedMap converts a map of any type to a map of a specific type V.
+// Values that cannot be converted to V will be omitted.
+func TypedMap[Map ~map[K]any, V any, K comparable](m Map) map[K]V {
+	result := make(map[K]V, len(m))
+	for k, v := range m {
+		if val, ok := v.(V); ok {
+			result[k] = val
+		}
+	}
+
+	return result
+}
diff --git a/loany/slice.go b/loany/slice.go
new file mode 100644
index 00000000..1ed637f5
--- /dev/null
+++ b/loany/slice.go
@@ -0,0 +1,23 @@
+package loany
+
+func Slice[Slice ~[]T, T any](xs Slice) []any {
+	result := make([]any, len(xs))
+	for i, x := range xs {
+		result[i] = x
+	}
+
+	return result
+}
+
+// TypedSlice converts a slice of any type to a slice of a specific type T.
+// Values that cannot be converted to T will be omitted.
+func TypedSlice[T any, Slice ~[]any](xs Slice) []T {
+	result := make([]T, 0, len(xs))
+	for _, x := range xs {
+		if v, ok := x.(T); ok {
+			result = append(result, v)
+		}
+	}
+
+	return result
+}
diff --git a/lofn/cmp.go b/lofn/cmp.go
new file mode 100644
index 00000000..d1537aa8
--- /dev/null
+++ b/lofn/cmp.go
@@ -0,0 +1,13 @@
+package lofn
+
+func CmpFromLess[T any](less func(a, b T) bool) func(a, b T) int {
+	return func(a, b T) int {
+		if less(a, b) {
+			return -1
+		} else if less(b, a) {
+			return 1
+		} else {
+			return 0
+		}
+	}
+}
diff --git a/lofn/internal/generate/not/generate_not.go b/lofn/internal/generate/not/generate_not.go
new file mode 100644
index 00000000..115b6910
--- /dev/null
+++ b/lofn/internal/generate/not/generate_not.go
@@ -0,0 +1,72 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/not/generate_not.go"
+	filename           = "not.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed not.gotmpl
+	notRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+	}
+	notTmpl := template.Must(template.New("not").Funcs(funcMap).Parse(notRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_not.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+
+	for n := 1; n <= argumentsLimit; n++ {
+		err := notTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lofn/internal/generate/not/not.gotmpl b/lofn/internal/generate/not/not.gotmpl
new file mode 100644
index 00000000..d2885949
--- /dev/null
+++ b/lofn/internal/generate/not/not.gotmpl
@@ -0,0 +1,13 @@
+{{- define "decls-types" -}}
+{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}
+{{- end }}
+{{- define "decls-args" -}}
+({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}v{{ add $i 1 }} T{{ add $i 1 }}{{ end }})
+{{- end }}
+func Not{{ if ne .N 1 }}{{ .N }}{{ end }}[{{ template "decls-types" . }} any](
+	pred func({{ template "decls-types" . }}) bool,
+) func({{ template "decls-types" . }}) bool {
+	return func{{ template "decls-args" . }} bool {
+		return !pred({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}v{{ add $i 1 }}{{ end }})
+	}
+}
diff --git a/lofn/internal/generate/optional/generate_optional.go b/lofn/internal/generate/optional/generate_optional.go
new file mode 100644
index 00000000..54ad9e23
--- /dev/null
+++ b/lofn/internal/generate/optional/generate_optional.go
@@ -0,0 +1,72 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/optional/generate_optional.go"
+	filename           = "optional.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed optional.gotmpl
+	optionalRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+	}
+	optionalTmpl := template.Must(template.New("optional").Funcs(funcMap).Parse(optionalRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_optional.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+
+	for n := 1; n <= argumentsLimit; n++ {
+		err := optionalTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lofn/internal/generate/optional/optional.gotmpl b/lofn/internal/generate/optional/optional.gotmpl
new file mode 100644
index 00000000..d03237f4
--- /dev/null
+++ b/lofn/internal/generate/optional/optional.gotmpl
@@ -0,0 +1,56 @@
+{{- define "decls-types" -}}
+{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}
+{{- end }}
+{{- define "decls-args" -}}
+{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}v{{ add $i 1 }} T{{ add $i 1 }}{{ end }}
+{{- end }}
+{{- define "decls-call-args" -}}
+{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}v{{ add $i 1 }}{{ end }}
+{{- end }}
+func OrDefault{{ if gt .N 1 }}{{ .N }}{{ end }}[{{ template "decls-types" . }}, R any](
+	fn func({{ template "decls-types" . }}) (R, bool),
+) func({{ template "decls-types" . }}, R) R {
+	return func({{ template "decls-args" . }}, fallback R) R {
+		if r, ok := fn({{ template "decls-call-args" . }}); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault{{ if gt .N 1 }}{{ .N }}{{ end }}[{{ template "decls-types" . }}, R any](
+	fn func({{ template "decls-types" . }}) (R, bool), fallback R,
+) func({{ template "decls-types" . }}) R {
+	return func({{ template "decls-args" . }}) R {
+		if r, ok := fn({{ template "decls-call-args" . }}); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback{{ if gt .N 1 }}{{ .N }}{{ end }}[{{ template "decls-types" . }}, R any](
+	fn func({{ template "decls-types" . }}) (R, bool),
+) func({{ template "decls-types" . }}, func({{ template "decls-types" . }}) R) R {
+	return func({{ template "decls-args" . }}, fallback func({{ template "decls-types" . }}) R) R {
+		if r, ok := fn({{ template "decls-call-args" . }}); ok {
+			return r
+		}
+
+		return fallback({{ template "decls-call-args" . }})
+	}
+}
+
+func WithFallback{{ if gt .N 1 }}{{ .N }}{{ end }}[{{ template "decls-types" . }}, R any](
+	fn func({{ template "decls-types" . }}) (R, bool), fallback func({{ template "decls-types" . }}) R,
+) func({{ template "decls-types" . }}) R {
+	return func({{ template "decls-args" . }}) R {
+		if r, ok := fn({{ template "decls-call-args" . }}); ok {
+			return r
+		}
+
+		return fallback({{ template "decls-call-args" . }})
+	}
+}
diff --git a/lofn/internal/generate/partial/generate_partial.go b/lofn/internal/generate/partial/generate_partial.go
new file mode 100644
index 00000000..6a38576f
--- /dev/null
+++ b/lofn/internal/generate/partial/generate_partial.go
@@ -0,0 +1,93 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+	"os/exec"
+	"strings"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/partial/generate_partial.go"
+	filename           = "partial.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+	resultsLimit   = 5
+)
+
+var (
+	//go:embed partial.gotmpl
+	partialRaw string
+)
+
+type Variant struct {
+	N, P, R int
+	Ctx     bool
+	Right   bool
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+		"sub": func(x, y int) int { return x - y },
+	}
+	partialTmpl := template.Must(template.New("not").Funcs(funcMap).Parse(partialRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_partial.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+	buf.WriteString("import (\n\t\"context\"\n)\n")
+
+	for _, rightMost := range []bool{false, true} {
+		for n := 1; n <= argumentsLimit; n++ {
+			if rightMost && n == 1 {
+				continue
+			}
+
+			for r := 0; r <= resultsLimit; r++ {
+				for _, takesCtx := range []bool{false, true} {
+					for p := 1; p <= n; p++ {
+						err := partialTmpl.Execute(&buf, Variant{
+							N: n, P: p, R: r,
+							Ctx:   takesCtx,
+							Right: rightMost,
+						})
+						if err != nil {
+							panic(err)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lofn/internal/generate/partial/partial.gotmpl b/lofn/internal/generate/partial/partial.gotmpl
new file mode 100644
index 00000000..9609e919
--- /dev/null
+++ b/lofn/internal/generate/partial/partial.gotmpl
@@ -0,0 +1,48 @@
+{{- define "decl-args-types" }}
+	{{- if .Ctx }}context.Context, {{ end -}}
+	{{- range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end -}}
+{{ end -}}
+{{- define "call-args" }}
+    {{- if .Ctx }}ctx{{ if .N }}, {{ end }}{{ end -}}
+    {{- range $i := .N }}{{ if ne $i 0 }}, {{ end }}t{{ add $i 1 }}{{ end -}}
+{{ end -}}
+{{- define "decl-offset-args" }}{{ $INC := add .P 1 }}
+	{{- if .Right }}{{ $INC = 1 }}{{ end -}}
+    {{- if .Ctx }}ctx context.Context{{ if ne .N .P}}, {{ end }}{{ end -}}
+    {{- range $i := (sub .N .P) }}{{ if ne $i 0 }}, {{ end }}t{{ add $i $INC }} T{{ add $i $INC }}{{ end -}}
+{{ end -}}
+{{- define "decl-offset-types" }}{{ $INC := add .P 1 }}
+	{{- if .Right }}{{ $INC = 1 }}{{ end -}}
+	{{- if .Ctx }}context.Context{{ if ne .N .P}}, {{ end }}{{ end -}}
+	{{- range $i := (sub .N .P) }}{{ if ne $i 0 }}, {{ end }}T{{ add $i $INC }}{{ end -}}
+{{ end -}}
+{{- define "decl-part-args" }}{{ $INC := 1 }}
+	{{- if .Right }}{{ $INC = add 1 (sub .N .P) }}{{ end -}}
+    {{- range $i := .P }}{{ if ne $i 0 }}, {{ end }}t{{ add $i $INC }} T{{ add $i $INC }}{{ end -}}
+{{ end -}}
+{{- define "decl-res" }}
+	{{- if .R }} {{ if gt .R 1 }}({{ end }}
+		{{- range $i := .R }}{{ if ne $i 0 }}, {{ end }}R{{ add $i 1 }}{{ end -}}
+		{{- if gt .R 1 }}){{ end -}}
+	{{ end -}}
+{{ end -}}
+{{- define "name-suffix" }}
+    {{- if ne 1 .N }}{{ .N }}{{ end -}}
+	{{- if ne 1 .P }}{{ .P }}{{ end -}}
+	{{- if eq 0 .R }}Void
+	{{- else if ne 1 .R }}R{{ .R }}{{ end -}}
+	{{- if .Ctx }}Ctx{{ end -}}
+{{ end -}}
+{{- define "types" }}
+	{{- range $i := .R }}R{{ add $i 1 }}, {{ end -}}
+	{{- range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end -}}
+{{ end -}}
+{{- $N := .N }}{{ $R := .R }}{{ $P := .P}}
+func {{ if .Right }}R{{ end }}Partial{{ template "name-suffix" . }}[{{ template "types" . }} any](
+	fn func({{ template "decl-args-types" . }}){{ template "decl-res" . }},
+	{{ template "decl-part-args" . }},
+) func({{ template "decl-offset-types" . }}){{ template "decl-res" . }} {
+	return func({{ template "decl-offset-args" . }}){{ template "decl-res" . }} {
+		{{ if .R }}return {{ end }}fn({{ template "call-args" . }})
+	}
+}
diff --git a/lofn/not.go b/lofn/not.go
new file mode 100644
index 00000000..6503eb68
--- /dev/null
+++ b/lofn/not.go
@@ -0,0 +1,76 @@
+// Code generated by generate_not.go; DO NOT EDIT.
+package lofn
+
+//go:generate go run internal/generate/not/generate_not.go
+
+func Not[T1 any](
+	pred func(T1) bool,
+) func(T1) bool {
+	return func(v1 T1) bool {
+		return !pred(v1)
+	}
+}
+
+func Not2[T1, T2 any](
+	pred func(T1, T2) bool,
+) func(T1, T2) bool {
+	return func(v1 T1, v2 T2) bool {
+		return !pred(v1, v2)
+	}
+}
+
+func Not3[T1, T2, T3 any](
+	pred func(T1, T2, T3) bool,
+) func(T1, T2, T3) bool {
+	return func(v1 T1, v2 T2, v3 T3) bool {
+		return !pred(v1, v2, v3)
+	}
+}
+
+func Not4[T1, T2, T3, T4 any](
+	pred func(T1, T2, T3, T4) bool,
+) func(T1, T2, T3, T4) bool {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4) bool {
+		return !pred(v1, v2, v3, v4)
+	}
+}
+
+func Not5[T1, T2, T3, T4, T5 any](
+	pred func(T1, T2, T3, T4, T5) bool,
+) func(T1, T2, T3, T4, T5) bool {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) bool {
+		return !pred(v1, v2, v3, v4, v5)
+	}
+}
+
+func Not6[T1, T2, T3, T4, T5, T6 any](
+	pred func(T1, T2, T3, T4, T5, T6) bool,
+) func(T1, T2, T3, T4, T5, T6) bool {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) bool {
+		return !pred(v1, v2, v3, v4, v5, v6)
+	}
+}
+
+func Not7[T1, T2, T3, T4, T5, T6, T7 any](
+	pred func(T1, T2, T3, T4, T5, T6, T7) bool,
+) func(T1, T2, T3, T4, T5, T6, T7) bool {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) bool {
+		return !pred(v1, v2, v3, v4, v5, v6, v7)
+	}
+}
+
+func Not8[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	pred func(T1, T2, T3, T4, T5, T6, T7, T8) bool,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) bool {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) bool {
+		return !pred(v1, v2, v3, v4, v5, v6, v7, v8)
+	}
+}
+
+func Not9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	pred func(T1, T2, T3, T4, T5, T6, T7, T8, T9) bool,
+) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) bool {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) bool {
+		return !pred(v1, v2, v3, v4, v5, v6, v7, v8, v9)
+	}
+}
diff --git a/lofn/optional.go b/lofn/optional.go
new file mode 100644
index 00000000..1dd48784
--- /dev/null
+++ b/lofn/optional.go
@@ -0,0 +1,436 @@
+// Code generated by generate_optional.go; DO NOT EDIT.
+package lofn
+
+//go:generate go run internal/generate/optional/generate_optional.go
+
+func OrDefault[T1, R any](
+	fn func(T1) (R, bool),
+) func(T1, R) R {
+	return func(v1 T1, fallback R) R {
+		if r, ok := fn(v1); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault[T1, R any](
+	fn func(T1) (R, bool), fallback R,
+) func(T1) R {
+	return func(v1 T1) R {
+		if r, ok := fn(v1); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback[T1, R any](
+	fn func(T1) (R, bool),
+) func(T1, func(T1) R) R {
+	return func(v1 T1, fallback func(T1) R) R {
+		if r, ok := fn(v1); ok {
+			return r
+		}
+
+		return fallback(v1)
+	}
+}
+
+func WithFallback[T1, R any](
+	fn func(T1) (R, bool), fallback func(T1) R,
+) func(T1) R {
+	return func(v1 T1) R {
+		if r, ok := fn(v1); ok {
+			return r
+		}
+
+		return fallback(v1)
+	}
+}
+
+func OrDefault2[T1, T2, R any](
+	fn func(T1, T2) (R, bool),
+) func(T1, T2, R) R {
+	return func(v1 T1, v2 T2, fallback R) R {
+		if r, ok := fn(v1, v2); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault2[T1, T2, R any](
+	fn func(T1, T2) (R, bool), fallback R,
+) func(T1, T2) R {
+	return func(v1 T1, v2 T2) R {
+		if r, ok := fn(v1, v2); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback2[T1, T2, R any](
+	fn func(T1, T2) (R, bool),
+) func(T1, T2, func(T1, T2) R) R {
+	return func(v1 T1, v2 T2, fallback func(T1, T2) R) R {
+		if r, ok := fn(v1, v2); ok {
+			return r
+		}
+
+		return fallback(v1, v2)
+	}
+}
+
+func WithFallback2[T1, T2, R any](
+	fn func(T1, T2) (R, bool), fallback func(T1, T2) R,
+) func(T1, T2) R {
+	return func(v1 T1, v2 T2) R {
+		if r, ok := fn(v1, v2); ok {
+			return r
+		}
+
+		return fallback(v1, v2)
+	}
+}
+
+func OrDefault3[T1, T2, T3, R any](
+	fn func(T1, T2, T3) (R, bool),
+) func(T1, T2, T3, R) R {
+	return func(v1 T1, v2 T2, v3 T3, fallback R) R {
+		if r, ok := fn(v1, v2, v3); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault3[T1, T2, T3, R any](
+	fn func(T1, T2, T3) (R, bool), fallback R,
+) func(T1, T2, T3) R {
+	return func(v1 T1, v2 T2, v3 T3) R {
+		if r, ok := fn(v1, v2, v3); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback3[T1, T2, T3, R any](
+	fn func(T1, T2, T3) (R, bool),
+) func(T1, T2, T3, func(T1, T2, T3) R) R {
+	return func(v1 T1, v2 T2, v3 T3, fallback func(T1, T2, T3) R) R {
+		if r, ok := fn(v1, v2, v3); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3)
+	}
+}
+
+func WithFallback3[T1, T2, T3, R any](
+	fn func(T1, T2, T3) (R, bool), fallback func(T1, T2, T3) R,
+) func(T1, T2, T3) R {
+	return func(v1 T1, v2 T2, v3 T3) R {
+		if r, ok := fn(v1, v2, v3); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3)
+	}
+}
+
+func OrDefault4[T1, T2, T3, T4, R any](
+	fn func(T1, T2, T3, T4) (R, bool),
+) func(T1, T2, T3, T4, R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, fallback R) R {
+		if r, ok := fn(v1, v2, v3, v4); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault4[T1, T2, T3, T4, R any](
+	fn func(T1, T2, T3, T4) (R, bool), fallback R,
+) func(T1, T2, T3, T4) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4) R {
+		if r, ok := fn(v1, v2, v3, v4); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback4[T1, T2, T3, T4, R any](
+	fn func(T1, T2, T3, T4) (R, bool),
+) func(T1, T2, T3, T4, func(T1, T2, T3, T4) R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, fallback func(T1, T2, T3, T4) R) R {
+		if r, ok := fn(v1, v2, v3, v4); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4)
+	}
+}
+
+func WithFallback4[T1, T2, T3, T4, R any](
+	fn func(T1, T2, T3, T4) (R, bool), fallback func(T1, T2, T3, T4) R,
+) func(T1, T2, T3, T4) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4) R {
+		if r, ok := fn(v1, v2, v3, v4); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4)
+	}
+}
+
+func OrDefault5[T1, T2, T3, T4, T5, R any](
+	fn func(T1, T2, T3, T4, T5) (R, bool),
+) func(T1, T2, T3, T4, T5, R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, fallback R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault5[T1, T2, T3, T4, T5, R any](
+	fn func(T1, T2, T3, T4, T5) (R, bool), fallback R,
+) func(T1, T2, T3, T4, T5) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) R {
+		if r, ok := fn(v1, v2, v3, v4, v5); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback5[T1, T2, T3, T4, T5, R any](
+	fn func(T1, T2, T3, T4, T5) (R, bool),
+) func(T1, T2, T3, T4, T5, func(T1, T2, T3, T4, T5) R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, fallback func(T1, T2, T3, T4, T5) R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5)
+	}
+}
+
+func WithFallback5[T1, T2, T3, T4, T5, R any](
+	fn func(T1, T2, T3, T4, T5) (R, bool), fallback func(T1, T2, T3, T4, T5) R,
+) func(T1, T2, T3, T4, T5) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) R {
+		if r, ok := fn(v1, v2, v3, v4, v5); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5)
+	}
+}
+
+func OrDefault6[T1, T2, T3, T4, T5, T6, R any](
+	fn func(T1, T2, T3, T4, T5, T6) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, fallback R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault6[T1, T2, T3, T4, T5, T6, R any](
+	fn func(T1, T2, T3, T4, T5, T6) (R, bool), fallback R,
+) func(T1, T2, T3, T4, T5, T6) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback6[T1, T2, T3, T4, T5, T6, R any](
+	fn func(T1, T2, T3, T4, T5, T6) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, func(T1, T2, T3, T4, T5, T6) R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, fallback func(T1, T2, T3, T4, T5, T6) R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6)
+	}
+}
+
+func WithFallback6[T1, T2, T3, T4, T5, T6, R any](
+	fn func(T1, T2, T3, T4, T5, T6) (R, bool), fallback func(T1, T2, T3, T4, T5, T6) R,
+) func(T1, T2, T3, T4, T5, T6) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6)
+	}
+}
+
+func OrDefault7[T1, T2, T3, T4, T5, T6, T7, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, T7, R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, fallback R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault7[T1, T2, T3, T4, T5, T6, T7, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R, bool), fallback R,
+) func(T1, T2, T3, T4, T5, T6, T7) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback7[T1, T2, T3, T4, T5, T6, T7, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, T7, func(T1, T2, T3, T4, T5, T6, T7) R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, fallback func(T1, T2, T3, T4, T5, T6, T7) R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6, v7)
+	}
+}
+
+func WithFallback7[T1, T2, T3, T4, T5, T6, T7, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R, bool), fallback func(T1, T2, T3, T4, T5, T6, T7) R,
+) func(T1, T2, T3, T4, T5, T6, T7) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6, v7)
+	}
+}
+
+func OrDefault8[T1, T2, T3, T4, T5, T6, T7, T8, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, T7, T8, R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, fallback R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault8[T1, T2, T3, T4, T5, T6, T7, T8, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R, bool), fallback R,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback8[T1, T2, T3, T4, T5, T6, T7, T8, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, T7, T8, func(T1, T2, T3, T4, T5, T6, T7, T8) R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, fallback func(T1, T2, T3, T4, T5, T6, T7, T8) R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6, v7, v8)
+	}
+}
+
+func WithFallback8[T1, T2, T3, T4, T5, T6, T7, T8, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R, bool), fallback func(T1, T2, T3, T4, T5, T6, T7, T8) R,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6, v7, v8)
+	}
+}
+
+func OrDefault9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9, fallback R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8, v9); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func WithDefault9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, bool), fallback R,
+) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8, v9); ok {
+			return r
+		}
+
+		return fallback
+	}
+}
+
+func OrFallback9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, bool),
+) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9, fallback func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8, v9); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6, v7, v8, v9)
+	}
+}
+
+func WithFallback9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, bool), fallback func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R,
+) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R {
+	return func(v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) R {
+		if r, ok := fn(v1, v2, v3, v4, v5, v6, v7, v8, v9); ok {
+			return r
+		}
+
+		return fallback(v1, v2, v3, v4, v5, v6, v7, v8, v9)
+	}
+}
diff --git a/lofn/partial.go b/lofn/partial.go
new file mode 100644
index 00000000..b0bb46b4
--- /dev/null
+++ b/lofn/partial.go
@@ -0,0 +1,9619 @@
+// Code generated by generate_partial.go; DO NOT EDIT.
+package lofn
+
+//go:generate go run internal/generate/partial/generate_partial.go
+import (
+	"context"
+)
+
+func PartialVoid[T1 any](
+	fn func(T1),
+	t1 T1,
+) func() {
+	return func() {
+		fn(t1)
+	}
+}
+
+func PartialVoidCtx[T1 any](
+	fn func(context.Context, T1),
+	t1 T1,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1)
+	}
+}
+
+func Partial[R1, T1 any](
+	fn func(T1) R1,
+	t1 T1,
+) func() R1 {
+	return func() R1 {
+		return fn(t1)
+	}
+}
+
+func PartialCtx[R1, T1 any](
+	fn func(context.Context, T1) R1,
+	t1 T1,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1)
+	}
+}
+
+func PartialR2[R1, R2, T1 any](
+	fn func(T1) (R1, R2),
+	t1 T1,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1)
+	}
+}
+
+func PartialR2Ctx[R1, R2, T1 any](
+	fn func(context.Context, T1) (R1, R2),
+	t1 T1,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1)
+	}
+}
+
+func PartialR3[R1, R2, R3, T1 any](
+	fn func(T1) (R1, R2, R3),
+	t1 T1,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1)
+	}
+}
+
+func PartialR3Ctx[R1, R2, R3, T1 any](
+	fn func(context.Context, T1) (R1, R2, R3),
+	t1 T1,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1)
+	}
+}
+
+func PartialR4[R1, R2, R3, R4, T1 any](
+	fn func(T1) (R1, R2, R3, R4),
+	t1 T1,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1)
+	}
+}
+
+func PartialR4Ctx[R1, R2, R3, R4, T1 any](
+	fn func(context.Context, T1) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1)
+	}
+}
+
+func PartialR5[R1, R2, R3, R4, R5, T1 any](
+	fn func(T1) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1)
+	}
+}
+
+func PartialR5Ctx[R1, R2, R3, R4, R5, T1 any](
+	fn func(context.Context, T1) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1)
+	}
+}
+
+func Partial2Void[T1, T2 any](
+	fn func(T1, T2),
+	t1 T1,
+) func(T2) {
+	return func(t2 T2) {
+		fn(t1, t2)
+	}
+}
+
+func Partial22Void[T1, T2 any](
+	fn func(T1, T2),
+	t1 T1, t2 T2,
+) func() {
+	return func() {
+		fn(t1, t2)
+	}
+}
+
+func Partial2VoidCtx[T1, T2 any](
+	fn func(context.Context, T1, T2),
+	t1 T1,
+) func(context.Context, T2) {
+	return func(ctx context.Context, t2 T2) {
+		fn(ctx, t1, t2)
+	}
+}
+
+func Partial22VoidCtx[T1, T2 any](
+	fn func(context.Context, T1, T2),
+	t1 T1, t2 T2,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2)
+	}
+}
+
+func Partial2[R1, T1, T2 any](
+	fn func(T1, T2) R1,
+	t1 T1,
+) func(T2) R1 {
+	return func(t2 T2) R1 {
+		return fn(t1, t2)
+	}
+}
+
+func Partial22[R1, T1, T2 any](
+	fn func(T1, T2) R1,
+	t1 T1, t2 T2,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2)
+	}
+}
+
+func Partial2Ctx[R1, T1, T2 any](
+	fn func(context.Context, T1, T2) R1,
+	t1 T1,
+) func(context.Context, T2) R1 {
+	return func(ctx context.Context, t2 T2) R1 {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial22Ctx[R1, T1, T2 any](
+	fn func(context.Context, T1, T2) R1,
+	t1 T1, t2 T2,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial2R2[R1, R2, T1, T2 any](
+	fn func(T1, T2) (R1, R2),
+	t1 T1,
+) func(T2) (R1, R2) {
+	return func(t2 T2) (R1, R2) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial22R2[R1, R2, T1, T2 any](
+	fn func(T1, T2) (R1, R2),
+	t1 T1, t2 T2,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial2R2Ctx[R1, R2, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2),
+	t1 T1,
+) func(context.Context, T2) (R1, R2) {
+	return func(ctx context.Context, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial22R2Ctx[R1, R2, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial2R3[R1, R2, R3, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3),
+	t1 T1,
+) func(T2) (R1, R2, R3) {
+	return func(t2 T2) (R1, R2, R3) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial22R3[R1, R2, R3, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial2R3Ctx[R1, R2, R3, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial22R3Ctx[R1, R2, R3, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial2R4[R1, R2, R3, R4, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2) (R1, R2, R3, R4) {
+	return func(t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial22R4[R1, R2, R3, R4, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial2R4Ctx[R1, R2, R3, R4, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial22R4Ctx[R1, R2, R3, R4, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial2R5[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2) (R1, R2, R3, R4, R5) {
+	return func(t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial22R5[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2)
+	}
+}
+
+func Partial2R5Ctx[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial22R5Ctx[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func Partial3Void[T1, T2, T3 any](
+	fn func(T1, T2, T3),
+	t1 T1,
+) func(T2, T3) {
+	return func(t2 T2, t3 T3) {
+		fn(t1, t2, t3)
+	}
+}
+
+func Partial32Void[T1, T2, T3 any](
+	fn func(T1, T2, T3),
+	t1 T1, t2 T2,
+) func(T3) {
+	return func(t3 T3) {
+		fn(t1, t2, t3)
+	}
+}
+
+func Partial33Void[T1, T2, T3 any](
+	fn func(T1, T2, T3),
+	t1 T1, t2 T2, t3 T3,
+) func() {
+	return func() {
+		fn(t1, t2, t3)
+	}
+}
+
+func Partial3VoidCtx[T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3),
+	t1 T1,
+) func(context.Context, T2, T3) {
+	return func(ctx context.Context, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial32VoidCtx[T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3),
+	t1 T1, t2 T2,
+) func(context.Context, T3) {
+	return func(ctx context.Context, t3 T3) {
+		fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial33VoidCtx[T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial3[R1, T1, T2, T3 any](
+	fn func(T1, T2, T3) R1,
+	t1 T1,
+) func(T2, T3) R1 {
+	return func(t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial32[R1, T1, T2, T3 any](
+	fn func(T1, T2, T3) R1,
+	t1 T1, t2 T2,
+) func(T3) R1 {
+	return func(t3 T3) R1 {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial33[R1, T1, T2, T3 any](
+	fn func(T1, T2, T3) R1,
+	t1 T1, t2 T2, t3 T3,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial3Ctx[R1, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) R1,
+	t1 T1,
+) func(context.Context, T2, T3) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial32Ctx[R1, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3) R1 {
+	return func(ctx context.Context, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial33Ctx[R1, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial3R2[R1, R2, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2),
+	t1 T1,
+) func(T2, T3) (R1, R2) {
+	return func(t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial32R2[R1, R2, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3) (R1, R2) {
+	return func(t3 T3) (R1, R2) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial33R2[R1, R2, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial3R2Ctx[R1, R2, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial32R2Ctx[R1, R2, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3) (R1, R2) {
+	return func(ctx context.Context, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial33R2Ctx[R1, R2, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial3R3[R1, R2, R3, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3) (R1, R2, R3) {
+	return func(t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial32R3[R1, R2, R3, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3) (R1, R2, R3) {
+	return func(t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial33R3[R1, R2, R3, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial3R3Ctx[R1, R2, R3, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial32R3Ctx[R1, R2, R3, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial33R3Ctx[R1, R2, R3, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial3R4[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial32R4[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3) (R1, R2, R3, R4) {
+	return func(t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial33R4[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial3R4Ctx[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial32R4Ctx[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial33R4Ctx[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial3R5[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial32R5[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3) (R1, R2, R3, R4, R5) {
+	return func(t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial33R5[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func Partial3R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial32R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial33R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func Partial4Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t1 T1,
+) func(T2, T3, T4) {
+	return func(t2 T2, t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial42Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t1 T1, t2 T2,
+) func(T3, T4) {
+	return func(t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial43Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4) {
+	return func(t4 T4) {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial44Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial4VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t1 T1,
+) func(context.Context, T2, T3, T4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial42VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4) {
+	return func(ctx context.Context, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial43VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4) {
+	return func(ctx context.Context, t4 T4) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial44VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial4[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t1 T1,
+) func(T2, T3, T4) R1 {
+	return func(t2 T2, t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial42[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t1 T1, t2 T2,
+) func(T3, T4) R1 {
+	return func(t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial43[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(T4) R1 {
+	return func(t4 T4) R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial44[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial4Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t1 T1,
+) func(context.Context, T2, T3, T4) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial42Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4) R1 {
+	return func(ctx context.Context, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial43Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4) R1 {
+	return func(ctx context.Context, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial44Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial4R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t1 T1,
+) func(T2, T3, T4) (R1, R2) {
+	return func(t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial42R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3, T4) (R1, R2) {
+	return func(t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial43R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(T4) (R1, R2) {
+	return func(t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial44R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial4R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial42R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial43R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4) (R1, R2) {
+	return func(ctx context.Context, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial44R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial4R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3, T4) (R1, R2, R3) {
+	return func(t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial42R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3, T4) (R1, R2, R3) {
+	return func(t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial43R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(T4) (R1, R2, R3) {
+	return func(t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial44R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial4R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial42R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial43R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial44R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial4R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3, T4) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial42R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3, T4) (R1, R2, R3, R4) {
+	return func(t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial43R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4) (R1, R2, R3, R4) {
+	return func(t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial44R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial4R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial42R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial43R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial44R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial4R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial42R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial43R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4) (R1, R2, R3, R4, R5) {
+	return func(t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial44R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func Partial4R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial42R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial43R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial44R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func Partial5Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t1 T1,
+) func(T2, T3, T4, T5) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t1 T1, t2 T2,
+) func(T3, T4, T5) {
+	return func(t3 T3, t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5) {
+	return func(t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5) {
+	return func(t5 T5) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5) {
+	return func(ctx context.Context, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5) {
+	return func(ctx context.Context, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t1 T1,
+) func(T2, T3, T4, T5) R1 {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2,
+) func(T3, T4, T5) R1 {
+	return func(t3 T3, t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5) R1 {
+	return func(t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5) R1 {
+	return func(t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5) R1 {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5) R1 {
+	return func(ctx context.Context, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5) R1 {
+	return func(ctx context.Context, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1,
+) func(T2, T3, T4, T5) (R1, R2) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3, T4, T5) (R1, R2) {
+	return func(t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5) (R1, R2) {
+	return func(t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5) (R1, R2) {
+	return func(t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5) (R1, R2) {
+	return func(ctx context.Context, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3, T4, T5) (R1, R2, R3) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3, T4, T5) (R1, R2, R3) {
+	return func(t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5) (R1, R2, R3) {
+	return func(t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5) (R1, R2, R3) {
+	return func(t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3, T4, T5) (R1, R2, R3, R4) {
+	return func(t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5) (R1, R2, R3, R4) {
+	return func(t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5) (R1, R2, R3, R4) {
+	return func(t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5) (R1, R2, R3, R4, R5) {
+	return func(t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial5R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial52R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial53R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial54R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial55R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func Partial6Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1,
+) func(T2, T3, T4, T5, T6) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6) {
+	return func(t4 T4, t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6) {
+	return func(t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6) {
+	return func(t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6) {
+	return func(ctx context.Context, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6) {
+	return func(ctx context.Context, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1,
+) func(T2, T3, T4, T5, T6) R1 {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6) R1 {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6) R1 {
+	return func(t4 T4, t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6) R1 {
+	return func(t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6) R1 {
+	return func(t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6) R1 {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6) R1 {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6) R1 {
+	return func(ctx context.Context, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6) R1 {
+	return func(ctx context.Context, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1,
+) func(T2, T3, T4, T5, T6) (R1, R2) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6) (R1, R2) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6) (R1, R2) {
+	return func(t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6) (R1, R2) {
+	return func(t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6) (R1, R2) {
+	return func(t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6) (R1, R2) {
+	return func(ctx context.Context, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6) (R1, R2, R3) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6) (R1, R2, R3) {
+	return func(t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6) (R1, R2, R3) {
+	return func(t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6) (R1, R2, R3) {
+	return func(t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6) (R1, R2, R3, R4) {
+	return func(t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6) (R1, R2, R3, R4) {
+	return func(t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6) (R1, R2, R3, R4) {
+	return func(t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6) (R1, R2, R3, R4, R5) {
+	return func(t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial6R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial62R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial63R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial64R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial65R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial66R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func Partial7Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7) {
+	return func(t5 T5, t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7) {
+	return func(t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7) {
+	return func(t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7) {
+	return func(ctx context.Context, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7) {
+	return func(ctx context.Context, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7) R1 {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7) R1 {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7) R1 {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7) R1 {
+	return func(t5 T5, t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7) R1 {
+	return func(t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7) R1 {
+	return func(t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7) R1 {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7) R1 {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7) R1 {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7) R1 {
+	return func(ctx context.Context, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7) R1 {
+	return func(ctx context.Context, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7) (R1, R2) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7) (R1, R2) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7) (R1, R2) {
+	return func(t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7) (R1, R2) {
+	return func(t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7) (R1, R2) {
+	return func(t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7) (R1, R2) {
+	return func(ctx context.Context, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7) (R1, R2, R3) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7) (R1, R2, R3) {
+	return func(t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7) (R1, R2, R3) {
+	return func(t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7) (R1, R2, R3) {
+	return func(t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7) (R1, R2, R3, R4) {
+	return func(t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7) (R1, R2, R3, R4) {
+	return func(t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7) (R1, R2, R3, R4) {
+	return func(t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7) (R1, R2, R3, R4, R5) {
+	return func(t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial7R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial72R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial73R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial74R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial75R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial76R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial77R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func Partial8Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8) {
+	return func(t6 T6, t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8) {
+	return func(t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8) {
+	return func(t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8) {
+	return func(ctx context.Context, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8) {
+	return func(ctx context.Context, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8) R1 {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8) R1 {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8) R1 {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8) R1 {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8) R1 {
+	return func(t6 T6, t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8) R1 {
+	return func(t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8) R1 {
+	return func(t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8) R1 {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8) R1 {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8) R1 {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8) R1 {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8) R1 {
+	return func(ctx context.Context, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8) R1 {
+	return func(ctx context.Context, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8) (R1, R2) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8) (R1, R2) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8) (R1, R2) {
+	return func(t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8) (R1, R2) {
+	return func(t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8) (R1, R2) {
+	return func(t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8) (R1, R2) {
+	return func(ctx context.Context, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8) (R1, R2, R3) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8) (R1, R2, R3) {
+	return func(t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8) (R1, R2, R3) {
+	return func(t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8) (R1, R2, R3) {
+	return func(t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8) (R1, R2, R3, R4) {
+	return func(t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8) (R1, R2, R3, R4) {
+	return func(t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8) (R1, R2, R3, R4) {
+	return func(t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8) (R1, R2, R3, R4, R5) {
+	return func(t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial8R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial82R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial83R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial84R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial85R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial86R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial87R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial88R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func Partial9Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8, T9) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8, T9) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8, T9) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8, T9) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8, T9) {
+	return func(t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8, T9) {
+	return func(t7 T7, t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8, T9) {
+	return func(t8 T8, t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T9) {
+	return func(t9 T9) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8, T9) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8, T9) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8, T9) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8, T9) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8, T9) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8, T9) {
+	return func(ctx context.Context, t7 T7, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8, T9) {
+	return func(ctx context.Context, t8 T8, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T9) {
+	return func(ctx context.Context, t9 T9) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8, T9) R1 {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8, T9) R1 {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8, T9) R1 {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8, T9) R1 {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8, T9) R1 {
+	return func(t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8, T9) R1 {
+	return func(t7 T7, t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8, T9) R1 {
+	return func(t8 T8, t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T9) R1 {
+	return func(t9 T9) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8, T9) R1 {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8, T9) R1 {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8, T9) R1 {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8, T9) R1 {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8, T9) R1 {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8, T9) R1 {
+	return func(ctx context.Context, t7 T7, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8, T9) R1 {
+	return func(ctx context.Context, t8 T8, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T9) R1 {
+	return func(ctx context.Context, t9 T9) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8, T9) (R1, R2) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8, T9) (R1, R2) {
+	return func(t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8, T9) (R1, R2) {
+	return func(t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8, T9) (R1, R2) {
+	return func(t8 T8, t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T9) (R1, R2) {
+	return func(t9 T9) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t7 T7, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8, T9) (R1, R2) {
+	return func(ctx context.Context, t8 T8, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T9) (R1, R2) {
+	return func(ctx context.Context, t9 T9) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8, T9) (R1, R2, R3) {
+	return func(t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8, T9) (R1, R2, R3) {
+	return func(t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8, T9) (R1, R2, R3) {
+	return func(t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T9) (R1, R2, R3) {
+	return func(t9 T9) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t7 T7, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t8 T8, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T9) (R1, R2, R3) {
+	return func(ctx context.Context, t9 T9) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8, T9) (R1, R2, R3, R4) {
+	return func(t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8, T9) (R1, R2, R3, R4) {
+	return func(t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T9) (R1, R2, R3, R4) {
+	return func(t9 T9) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t8 T8, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T9) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t9 T9) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T8, T9) (R1, R2, R3, R4, R5) {
+	return func(t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T9) (R1, R2, R3, R4, R5) {
+	return func(t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial9R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1,
+) func(context.Context, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial92R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial93R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial94R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial95R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T6, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t6 T6, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial96R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T7, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t7 T7, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial97R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T8, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t8 T8, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial98R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T9) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t9 T9) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func Partial99R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial2Void[T1, T2 any](
+	fn func(T1, T2),
+	t2 T2,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2)
+	}
+}
+
+func RPartial22Void[T1, T2 any](
+	fn func(T1, T2),
+	t1 T1, t2 T2,
+) func() {
+	return func() {
+		fn(t1, t2)
+	}
+}
+
+func RPartial2VoidCtx[T1, T2 any](
+	fn func(context.Context, T1, T2),
+	t2 T2,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2)
+	}
+}
+
+func RPartial22VoidCtx[T1, T2 any](
+	fn func(context.Context, T1, T2),
+	t1 T1, t2 T2,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2)
+	}
+}
+
+func RPartial2[R1, T1, T2 any](
+	fn func(T1, T2) R1,
+	t2 T2,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial22[R1, T1, T2 any](
+	fn func(T1, T2) R1,
+	t1 T1, t2 T2,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial2Ctx[R1, T1, T2 any](
+	fn func(context.Context, T1, T2) R1,
+	t2 T2,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial22Ctx[R1, T1, T2 any](
+	fn func(context.Context, T1, T2) R1,
+	t1 T1, t2 T2,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial2R2[R1, R2, T1, T2 any](
+	fn func(T1, T2) (R1, R2),
+	t2 T2,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial22R2[R1, R2, T1, T2 any](
+	fn func(T1, T2) (R1, R2),
+	t1 T1, t2 T2,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial2R2Ctx[R1, R2, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2),
+	t2 T2,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial22R2Ctx[R1, R2, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial2R3[R1, R2, R3, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3),
+	t2 T2,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial22R3[R1, R2, R3, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial2R3Ctx[R1, R2, R3, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3),
+	t2 T2,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial22R3Ctx[R1, R2, R3, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial2R4[R1, R2, R3, R4, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4),
+	t2 T2,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial22R4[R1, R2, R3, R4, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial2R4Ctx[R1, R2, R3, R4, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4),
+	t2 T2,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial22R4Ctx[R1, R2, R3, R4, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial2R5[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4, R5),
+	t2 T2,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial22R5[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(T1, T2) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2)
+	}
+}
+
+func RPartial2R5Ctx[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4, R5),
+	t2 T2,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial22R5Ctx[R1, R2, R3, R4, R5, T1, T2 any](
+	fn func(context.Context, T1, T2) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2)
+	}
+}
+
+func RPartial3Void[T1, T2, T3 any](
+	fn func(T1, T2, T3),
+	t3 T3,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3)
+	}
+}
+
+func RPartial32Void[T1, T2, T3 any](
+	fn func(T1, T2, T3),
+	t2 T2, t3 T3,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3)
+	}
+}
+
+func RPartial33Void[T1, T2, T3 any](
+	fn func(T1, T2, T3),
+	t1 T1, t2 T2, t3 T3,
+) func() {
+	return func() {
+		fn(t1, t2, t3)
+	}
+}
+
+func RPartial3VoidCtx[T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3),
+	t3 T3,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial32VoidCtx[T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3),
+	t2 T2, t3 T3,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial33VoidCtx[T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial3[R1, T1, T2, T3 any](
+	fn func(T1, T2, T3) R1,
+	t3 T3,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial32[R1, T1, T2, T3 any](
+	fn func(T1, T2, T3) R1,
+	t2 T2, t3 T3,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial33[R1, T1, T2, T3 any](
+	fn func(T1, T2, T3) R1,
+	t1 T1, t2 T2, t3 T3,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial3Ctx[R1, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) R1,
+	t3 T3,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial32Ctx[R1, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) R1,
+	t2 T2, t3 T3,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial33Ctx[R1, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) R1,
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial3R2[R1, R2, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2),
+	t3 T3,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial32R2[R1, R2, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2),
+	t2 T2, t3 T3,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial33R2[R1, R2, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial3R2Ctx[R1, R2, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2),
+	t3 T3,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial32R2Ctx[R1, R2, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2),
+	t2 T2, t3 T3,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial33R2Ctx[R1, R2, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial3R3[R1, R2, R3, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3),
+	t3 T3,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial32R3[R1, R2, R3, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3),
+	t2 T2, t3 T3,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial33R3[R1, R2, R3, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial3R3Ctx[R1, R2, R3, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3),
+	t3 T3,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial32R3Ctx[R1, R2, R3, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3),
+	t2 T2, t3 T3,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial33R3Ctx[R1, R2, R3, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial3R4[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4),
+	t3 T3,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial32R4[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4),
+	t2 T2, t3 T3,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial33R4[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial3R4Ctx[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4),
+	t3 T3,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial32R4Ctx[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4),
+	t2 T2, t3 T3,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial33R4Ctx[R1, R2, R3, R4, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial3R5[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4, R5),
+	t3 T3,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial32R5[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial33R5[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3)
+	}
+}
+
+func RPartial3R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5),
+	t3 T3,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial32R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial33R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3 any](
+	fn func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3)
+	}
+}
+
+func RPartial4Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t4 T4,
+) func(T1, T2, T3) {
+	return func(t1 T1, t2 T2, t3 T3) {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial42Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t3 T3, t4 T4,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial43Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t2 T2, t3 T3, t4 T4,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial44Void[T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial4VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t4 T4,
+) func(context.Context, T1, T2, T3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial42VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t3 T3, t4 T4,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial43VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t2 T2, t3 T3, t4 T4,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial44VoidCtx[T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial4[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t4 T4,
+) func(T1, T2, T3) R1 {
+	return func(t1 T1, t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial42[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t3 T3, t4 T4,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial43[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t2 T2, t3 T3, t4 T4,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial44[R1, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial4Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t4 T4,
+) func(context.Context, T1, T2, T3) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial42Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t3 T3, t4 T4,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial43Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t2 T2, t3 T3, t4 T4,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial44Ctx[R1, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t4 T4,
+) func(T1, T2, T3) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t3 T3, t4 T4,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t2 T2, t3 T3, t4 T4,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R2[R1, R2, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t4 T4,
+) func(context.Context, T1, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t3 T3, t4 T4,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t2 T2, t3 T3, t4 T4,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R2Ctx[R1, R2, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t4 T4,
+) func(T1, T2, T3) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t3 T3, t4 T4,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R3[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t4 T4,
+) func(context.Context, T1, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t3 T3, t4 T4,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R3Ctx[R1, R2, R3, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t4 T4,
+) func(T1, T2, T3) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t3 T3, t4 T4,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R4[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t4 T4,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t3 T3, t4 T4,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t4 T4,
+) func(T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R5[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4)
+	}
+}
+
+func RPartial4R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t4 T4,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial42R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial43R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial44R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4 any](
+	fn func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4)
+	}
+}
+
+func RPartial5Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t5 T5,
+) func(T1, T2, T3, T4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t4 T4, t5 T5,
+) func(T1, T2, T3) {
+	return func(t1 T1, t2 T2, t3 T3) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t3 T3, t4 T4, t5 T5,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55Void[T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t5 T5,
+) func(context.Context, T1, T2, T3, T4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t4 T4, t5 T5,
+) func(context.Context, T1, T2, T3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55VoidCtx[T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t5 T5,
+) func(T1, T2, T3, T4) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t4 T4, t5 T5,
+) func(T1, T2, T3) R1 {
+	return func(t1 T1, t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t3 T3, t4 T4, t5 T5,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55[R1, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t5 T5,
+) func(context.Context, T1, T2, T3, T4) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t4 T4, t5 T5,
+) func(context.Context, T1, T2, T3) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55Ctx[R1, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t5 T5,
+) func(T1, T2, T3, T4) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t4 T4, t5 T5,
+) func(T1, T2, T3) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t3 T3, t4 T4, t5 T5,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R2[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t5 T5,
+) func(context.Context, T1, T2, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t4 T4, t5 T5,
+) func(context.Context, T1, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R2Ctx[R1, R2, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t5 T5,
+) func(T1, T2, T3, T4) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t4 T4, t5 T5,
+) func(T1, T2, T3) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R3[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t5 T5,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t4 T4, t5 T5,
+) func(context.Context, T1, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t5 T5,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t4 T4, t5 T5,
+) func(T1, T2, T3) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R4[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t5 T5,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t4 T4, t5 T5,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t5 T5,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5,
+) func(T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial5R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t5 T5,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial52R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial53R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial54R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial55R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5 any](
+	fn func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5)
+	}
+}
+
+func RPartial6Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t6 T6,
+) func(T1, T2, T3, T4, T5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t5 T5, t6 T6,
+) func(T1, T2, T3, T4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t4 T4, t5 T5, t6 T6,
+) func(T1, T2, T3) {
+	return func(t1 T1, t2 T2, t3 T3) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66Void[T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t6 T6,
+) func(context.Context, T1, T2, T3, T4, T5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3, T4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66VoidCtx[T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t6 T6,
+) func(T1, T2, T3, T4, T5) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t5 T5, t6 T6,
+) func(T1, T2, T3, T4) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t4 T4, t5 T5, t6 T6,
+) func(T1, T2, T3) R1 {
+	return func(t1 T1, t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t6 T6,
+) func(context.Context, T1, T2, T3, T4, T5) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3, T4) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66Ctx[R1, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t6 T6,
+) func(T1, T2, T3, T4, T5) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t5 T5, t6 T6,
+) func(T1, T2, T3, T4) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t4 T4, t5 T5, t6 T6,
+) func(T1, T2, T3) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R2[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t6 T6,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t6 T6,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t5 T5, t6 T6,
+) func(T1, T2, T3, T4) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6,
+) func(T1, T2, T3) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R3[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t6 T6,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t6 T6,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t5 T5, t6 T6,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6,
+) func(T1, T2, T3) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t6 T6,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t6 T6,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6,
+) func(T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial6R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t6 T6,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial62R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial63R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial64R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial65R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial66R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6)
+	}
+}
+
+func RPartial7Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t7 T7,
+) func(T1, T2, T3, T4, T5, T6) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t6 T6, t7 T7,
+) func(T1, T2, T3, T4, T5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3, T4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3) {
+	return func(t1 T1, t2 T2, t3 T3) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77Void[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5, T6) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77VoidCtx[T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t7 T7,
+) func(T1, T2, T3, T4, T5, T6) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t6 T6, t7 T7,
+) func(T1, T2, T3, T4, T5) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3, T4) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3) R1 {
+	return func(t1 T1, t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5, T6) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77Ctx[R1, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t7 T7,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t6 T6, t7 T7,
+) func(T1, T2, T3, T4, T5) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3, T4) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R2[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t7 T7,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t6 T6, t7 T7,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3, T4) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t7 T7,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t6 T6, t7 T7,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t7 T7,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t6 T6, t7 T7,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial7R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial72R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial73R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial74R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial75R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial76R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial77R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7)
+	}
+}
+
+func RPartial8Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t8 T8,
+) func(T1, T2, T3, T4, T5, T6, T7) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5, T6) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3) {
+	return func(t1 T1, t2 T2, t3 T3) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88Void[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t8 T8,
+) func(T1, T2, T3, T4, T5, T6, T7) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5, T6) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3) R1 {
+	return func(t1 T1, t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t8 T8,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t8 T8,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t8 T8,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t8 T8,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial8R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial82R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial83R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial84R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial85R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial86R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial87R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial88R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8)
+	}
+}
+
+func RPartial9Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3) {
+	return func(t1 T1, t2 T2, t3 T3) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2) {
+	return func(t1 T1, t2 T2) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1) {
+	return func(t1 T1) {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99Void[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() {
+	return func() {
+		fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2) {
+	return func(ctx context.Context, t1 T1, t2 T2) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1) {
+	return func(ctx context.Context, t1 T1) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99VoidCtx[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) {
+	return func(ctx context.Context) {
+		fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4) R1 {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3) R1 {
+	return func(t1 T1, t2 T2, t3 T3) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2) R1 {
+	return func(t1 T1, t2 T2) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1) R1 {
+	return func(t1 T1) R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() R1 {
+	return func() R1 {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2) R1 {
+	return func(ctx context.Context, t1 T1, t2 T2) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1) R1 {
+	return func(ctx context.Context, t1 T1) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99Ctx[R1, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) R1,
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) R1 {
+	return func(ctx context.Context) R1 {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3) (R1, R2) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2) (R1, R2) {
+	return func(t1 T1, t2 T2) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1) (R1, R2) {
+	return func(t1 T1) (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R2[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2) {
+	return func() (R1, R2) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2) (R1, R2) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1) (R1, R2) {
+	return func(ctx context.Context, t1 T1) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R2Ctx[R1, R2, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2) {
+	return func(ctx context.Context) (R1, R2) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3) (R1, R2, R3) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2) (R1, R2, R3) {
+	return func(t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1) (R1, R2, R3) {
+	return func(t1 T1) (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R3[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2, R3) {
+	return func() (R1, R2, R3) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1) (R1, R2, R3) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R3Ctx[R1, R2, R3, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2, R3) {
+	return func(ctx context.Context) (R1, R2, R3) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2) (R1, R2, R3, R4) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1) (R1, R2, R3, R4) {
+	return func(t1 T1) (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R4[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2, R3, R4) {
+	return func() (R1, R2, R3, R4) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1) (R1, R2, R3, R4) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R4Ctx[R1, R2, R3, R4, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2, R3, R4) {
+	return func(ctx context.Context) (R1, R2, R3, R4) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1, T2) (R1, R2, R3, R4, R5) {
+	return func(t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(T1) (R1, R2, R3, R4, R5) {
+	return func(t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R5[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func() (R1, R2, R3, R4, R5) {
+	return func() (R1, R2, R3, R4, R5) {
+		return fn(t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial9R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial92R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6, T7) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial93R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5, T6) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial94R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4, T5) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial95R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3, T4) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3, t4 T4) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial96R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2, T3) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2, t3 T3) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial97R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1, T2) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1, t2 T2) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial98R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context, T1) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context, t1 T1) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
+
+func RPartial99R5Ctx[R1, R2, R3, R4, R5, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
+	fn func(context.Context, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R1, R2, R3, R4, R5),
+	t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9,
+) func(context.Context) (R1, R2, R3, R4, R5) {
+	return func(ctx context.Context) (R1, R2, R3, R4, R5) {
+		return fn(ctx, t1, t2, t3, t4, t5, t6, t7, t8, t9)
+	}
+}
diff --git a/lomap/clustering.go b/lomap/clustering.go
new file mode 100644
index 00000000..b65b8a7d
--- /dev/null
+++ b/lomap/clustering.go
@@ -0,0 +1,208 @@
+package lomap
+
+func ClusterValues[Map ~map[K]V, C, K comparable, V any](m Map, fcluster func(V) C) (clusters map[C]Map) {
+	clusters = make(map[C]Map)
+
+	for k, v := range m {
+		c := fcluster(v)
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(Map)
+		}
+
+		clusters[c][k] = v
+	}
+
+	return clusters
+}
+
+func ClusterKeys[Map ~map[K]V, C, K comparable, V any](m Map, fcluster func(K) C) (clusters map[C]Map) {
+	clusters = make(map[C]Map)
+
+	for k, v := range m {
+		c := fcluster(k)
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(Map)
+		}
+
+		clusters[c][k] = v
+	}
+
+	return clusters
+}
+
+func ClusterPairs[Map ~map[K]V, C, K comparable, V any](m Map, fcluster func(K, V) C) (clusters map[C]Map) {
+	clusters = make(map[C]Map)
+
+	for k, v := range m {
+		c := fcluster(k, v)
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(Map)
+		}
+
+		clusters[c][k] = v
+	}
+
+	return clusters
+}
+
+func FilterClusterValues[Map ~map[K]V, C, K comparable, V any](m Map, fcluster func(V) (C, bool)) (clusters map[C]Map) {
+	clusters = make(map[C]Map)
+
+	for k, v := range m {
+		c, ok := fcluster(v)
+		if !ok {
+			continue
+		}
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(Map)
+		}
+
+		clusters[c][k] = v
+	}
+
+	return clusters
+}
+
+func FilterClusterKeys[Map ~map[K]V, C, K comparable, V any](m Map, fcluster func(K) (C, bool)) (clusters map[C]Map) {
+	clusters = make(map[C]Map)
+
+	for k, v := range m {
+		c, ok := fcluster(k)
+		if !ok {
+			continue
+		}
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(Map)
+		}
+
+		clusters[c][k] = v
+	}
+
+	return clusters
+}
+
+func FilterClusterPairs[Map ~map[K]V, C, K comparable, V any](m Map, fcluster func(K, V) (C, bool)) (clusters map[C]Map) {
+	clusters = make(map[C]Map)
+
+	for k, v := range m {
+		c, ok := fcluster(k, v)
+		if !ok {
+			continue
+		}
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(Map)
+		}
+
+		clusters[c][k] = v
+	}
+
+	return clusters
+}
+
+func FilterMapClusterValues[Map ~map[K]V, C, K comparable, V, R any](m Map, fmapcluster func(V) (C, R, bool)) (clusters map[C]map[K][]R) {
+	clusters = make(map[C]map[K][]R)
+
+	for k, v := range m {
+		c, r, ok := fmapcluster(v)
+		if !ok {
+			continue
+		}
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(map[K][]R)
+		}
+
+		clusters[c][k] = append(clusters[c][k], r)
+	}
+
+	return clusters
+}
+
+func FilterMapClusterKeys[Map ~map[K]V, C, K comparable, V, R any](m Map, fmapcluster func(K) (C, R, bool)) (clusters map[C]map[K][]R) {
+	clusters = make(map[C]map[K][]R)
+
+	for k := range m {
+		c, r, ok := fmapcluster(k)
+		if !ok {
+			continue
+		}
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(map[K][]R)
+		}
+
+		clusters[c][k] = append(clusters[c][k], r)
+	}
+
+	return clusters
+}
+
+func FilterMapClusterPairs[Map ~map[K]V, C, K comparable, V, R any](m Map, fmapcluster func(K, V) (C, R, bool)) (clusters map[C]map[K][]R) {
+	clusters = make(map[C]map[K][]R)
+
+	for k, v := range m {
+		c, r, ok := fmapcluster(k, v)
+		if !ok {
+			continue
+		}
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(map[K][]R)
+		}
+
+		clusters[c][k] = append(clusters[c][k], r)
+	}
+
+	return clusters
+}
+
+func MapClusterValues[Map ~map[K]V, C, K comparable, V, R any](m Map, fmapcluster func(V) (C, R)) (clusters map[C]map[K][]R) {
+	clusters = make(map[C]map[K][]R)
+
+	for k, v := range m {
+		c, r := fmapcluster(v)
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(map[K][]R)
+		}
+
+		clusters[c][k] = append(clusters[c][k], r)
+	}
+
+	return clusters
+}
+
+func MapClusterKeys[Map ~map[K]V, C, K comparable, V, R any](m Map, fmapcluster func(K) (C, R)) (clusters map[C]map[K][]R) {
+	clusters = make(map[C]map[K][]R)
+
+	for k := range m {
+		c, r := fmapcluster(k)
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(map[K][]R)
+		}
+
+		clusters[c][k] = append(clusters[c][k], r)
+	}
+
+	return clusters
+}
+
+func MapClusterPairs[Map ~map[K]V, C, K comparable, V, R any](m Map, fmapcluster func(K, V) (C, R)) (clusters map[C]map[K][]R) {
+	clusters = make(map[C]map[K][]R)
+
+	for k, v := range m {
+		c, r := fmapcluster(k, v)
+
+		if _, exists := clusters[c]; !exists {
+			clusters[c] = make(map[K][]R)
+		}
+
+		clusters[c][k] = append(clusters[c][k], r)
+	}
+
+	return clusters
+}
diff --git a/lomap/constructor.go b/lomap/constructor.go
new file mode 100644
index 00000000..78d13577
--- /dev/null
+++ b/lomap/constructor.go
@@ -0,0 +1,81 @@
+package lomap
+
+import "github.com/samber/lo/lotup"
+
+func Zip[K comparable, V any](keys []K, values []V) (m map[K]V) {
+	size := min(len(keys), len(values))
+	m = make(map[K]V, size)
+	for i := range size {
+		m[keys[i]] = values[i]
+	}
+
+	return m
+}
+
+func FromPairs[K comparable, V any](pairs []lotup.Tuple2[K, V]) (m map[K]V) {
+	m = make(map[K]V, len(pairs))
+	for _, p := range pairs {
+		m[p.V1] = p.V2
+	}
+
+	return m
+}
+
+func FromKeysAndDefault[K comparable, V any](keys []K, value V) (m map[K]V) {
+	m = make(map[K]V, len(keys))
+	for _, k := range keys {
+		m[k] = value
+	}
+
+	return m
+}
+
+func FromKeys[K comparable, V any](keys []K, fmap func(K) V) (m map[K]V) {
+	m = make(map[K]V, len(keys))
+	for _, k := range keys {
+		m[k] = fmap(k)
+	}
+
+	return m
+}
+
+func IFromKeys[K comparable, V any](keys []K, imap func(int, K) V) (m map[K]V) {
+	m = make(map[K]V, len(keys))
+	for i, k := range keys {
+		m[k] = imap(i, k)
+	}
+
+	return m
+}
+
+func FromValues[K comparable, V any](values []V, fmap func(V) K) (m map[K]V) {
+	m = make(map[K]V, len(values))
+	for _, v := range values {
+		m[fmap(v)] = v
+	}
+
+	return m
+}
+
+func IFromValues[K comparable, V any](values []V, imap func(int, V) K) (m map[K]V) {
+	m = make(map[K]V, len(values))
+	for i, v := range values {
+		m[imap(i, v)] = v
+	}
+
+	return m
+}
+
+func Fill[K comparable, V any](size int, get func(int) (K, V)) (m map[K]V) {
+	if size < 0 {
+		return nil
+	}
+
+	m = make(map[K]V, size)
+	for i := 0; i < size; i++ {
+		k, v := get(i)
+		m[k] = v
+	}
+
+	return m
+}
diff --git a/lomap/count.go b/lomap/count.go
new file mode 100644
index 00000000..c008fe11
--- /dev/null
+++ b/lomap/count.go
@@ -0,0 +1,31 @@
+package lomap
+
+func CountKeys[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) (count int) {
+	for k := range m {
+		if pred(k) {
+			count++
+		}
+	}
+
+	return count
+}
+
+func CountValues[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) (count int) {
+	for _, v := range m {
+		if pred(v) {
+			count++
+		}
+	}
+
+	return count
+}
+
+func CountPairs[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) (count int) {
+	for k, v := range m {
+		if pred(k, v) {
+			count++
+		}
+	}
+
+	return count
+}
diff --git a/lomap/filter.go b/lomap/filter.go
new file mode 100644
index 00000000..0dab6ae8
--- /dev/null
+++ b/lomap/filter.go
@@ -0,0 +1,45 @@
+package lomap
+
+func RejectVal[Map ~map[K]V, K, V comparable](m Map, val V) (filtered Map) {
+	filtered = make(Map, len(m))
+	for k, v := range m {
+		if v != val {
+			filtered[k] = v
+		}
+	}
+
+	return filtered
+}
+
+func FilterKeys[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) (filtered Map) {
+	filtered = make(Map, len(m))
+	for k, v := range m {
+		if pred(k) {
+			filtered[k] = v
+		}
+	}
+
+	return filtered
+}
+
+func FilterValues[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) (filtered Map) {
+	filtered = make(Map, len(m))
+	for k, v := range m {
+		if pred(v) {
+			filtered[k] = v
+		}
+	}
+
+	return filtered
+}
+
+func FilterPairs[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) (filtered Map) {
+	filtered = make(Map, len(m))
+	for k, v := range m {
+		if pred(k, v) {
+			filtered[k] = v
+		}
+	}
+
+	return filtered
+}
diff --git a/lomap/find.go b/lomap/find.go
new file mode 100644
index 00000000..f94d7707
--- /dev/null
+++ b/lomap/find.go
@@ -0,0 +1,41 @@
+package lomap
+
+func FindVal[Map ~map[K]V, K, V comparable](m Map, v V) (k K, ok bool) {
+	for k, val := range m {
+		if val == v {
+			return k, true
+		}
+	}
+
+	return
+}
+
+func FindKey[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) (k K, ok bool) {
+	for k := range m {
+		if pred(k) {
+			return k, true
+		}
+	}
+
+	return
+}
+
+func Find[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) (k K, ok bool) {
+	for k, v := range m {
+		if pred(v) {
+			return k, true
+		}
+	}
+
+	return
+}
+
+func KFind[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) (k K, ok bool) {
+	for k, v := range m {
+		if pred(k, v) {
+			return k, true
+		}
+	}
+
+	return
+}
diff --git a/lomap/getter.go b/lomap/getter.go
new file mode 100644
index 00000000..7eeb9ebc
--- /dev/null
+++ b/lomap/getter.go
@@ -0,0 +1,48 @@
+package lomap
+
+func NewGetter[Map ~map[K]V, K comparable, V any](m Map) func(K) (V, bool) {
+	return func(k K) (v V, ok bool) {
+		v, ok = m[k]
+		return
+	}
+}
+
+func NewGetterWithDefault[Map ~map[K]V, K comparable, V any](m Map, defaultValue V) func(K) V {
+	return func(k K) V {
+		if v, ok := m[k]; ok {
+			return v
+		}
+
+		return defaultValue
+	}
+}
+
+func NewGetterOrDefault[Map ~map[K]V, K comparable, V any](m Map) func(K, V) V {
+	return func(k K, defaultValue V) V {
+		if v, ok := m[k]; ok {
+			return v
+		}
+
+		return defaultValue
+	}
+}
+
+func NewGetterWithFallback[Map ~map[K]V, K comparable, V any](m Map, fallback func(K) V) func(K) V {
+	return func(k K) V {
+		if v, ok := m[k]; ok {
+			return v
+		}
+
+		return fallback(k)
+	}
+}
+
+func NewGetterOrFallback[Map ~map[K]V, K comparable, V any](m Map) func(K, func(K) V) V {
+	return func(k K, fallback func(K) V) V {
+		if v, ok := m[k]; ok {
+			return v
+		}
+
+		return fallback(k)
+	}
+}
diff --git a/lomap/grouping.go b/lomap/grouping.go
new file mode 100644
index 00000000..47468dd0
--- /dev/null
+++ b/lomap/grouping.go
@@ -0,0 +1,93 @@
+package lomap
+
+func Group[Slice ~[]T, T any, K comparable](xs Slice, fkey func(T) K) map[K]Slice {
+	m := make(map[K]Slice, len(xs))
+
+	for _, x := range xs {
+		k := fkey(x)
+		m[k] = append(m[k], x)
+	}
+
+	return m
+}
+
+func IGroup[Slice ~[]T, T any, K comparable](xs Slice, ikey func(int, T) K) map[K]Slice {
+	m := make(map[K]Slice, len(xs))
+
+	for i, x := range xs {
+		k := ikey(i, x)
+		m[k] = append(m[k], x)
+	}
+
+	return m
+}
+
+func GroupMap[Slice ~[]T, V, T any, K comparable](xs Slice, fmap func(T) (K, V)) map[K][]V {
+	m := make(map[K][]V, len(xs))
+
+	for _, x := range xs {
+		k, v := fmap(x)
+		m[k] = append(m[k], v)
+	}
+
+	return m
+}
+
+func IGroupMap[Slice ~[]T, V, T any, K comparable](xs Slice, ifmap func(int, T) (K, V)) map[K][]V {
+	m := make(map[K][]V, len(xs))
+
+	for i, x := range xs {
+		k, v := ifmap(i, x)
+		m[k] = append(m[k], v)
+	}
+
+	return m
+}
+
+func GroupFilter[Slice ~[]T, T any, K comparable](xs Slice, fkey func(T) (K, bool)) map[K]Slice {
+	m := make(map[K]Slice, len(xs))
+
+	for _, x := range xs {
+		if k, ok := fkey(x); ok {
+			m[k] = append(m[k], x)
+		}
+	}
+
+	return m
+}
+
+func IGroupFilter[Slice ~[]T, T any, K comparable](xs Slice, ifkey func(int, T) (K, bool)) map[K]Slice {
+	m := make(map[K]Slice, len(xs))
+
+	for i, x := range xs {
+		if k, ok := ifkey(i, x); ok {
+			m[k] = append(m[k], x)
+		}
+	}
+
+	return m
+}
+
+func GroupFilterMap[Slice ~[]T, V, T any, K comparable](xs Slice, fmap func(T) (K, V, bool)) map[K][]V {
+	m := make(map[K][]V, len(xs))
+
+	for _, x := range xs {
+		if k, v, ok := fmap(x); ok {
+			m[k] = append(m[k], v)
+		}
+	}
+
+	return m
+}
+
+func IGroupFilterMap[Slice ~[]T, V, T any, K comparable](xs Slice, ifmap func(int, T) (K, V, bool)) map[K][]V {
+	m := make(map[K][]V, len(xs))
+
+	for i, x := range xs {
+		if k, v, ok := ifmap(i, x); ok {
+			m[k] = append(m[k], v)
+		}
+	}
+
+	return m
+}
diff --git a/lomap/internal/generate/nested/generate_nested.go b/lomap/internal/generate/nested/generate_nested.go
new file mode 100644
index 00000000..d5460419
--- /dev/null
+++ b/lomap/internal/generate/nested/generate_nested.go
@@ -0,0 +1,73 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/nested/generate_nested.go"
+	filename           = "nested.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed nested.gotmpl
+	nestedRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+		"sub": func(x, y int) int { return x - y },
+	}
+	nestedTmpl := template.Must(template.New("nested").Funcs(funcMap).Parse(nestedRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_nested.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+
+	for n := 2; n <= argumentsLimit; n++ {
+		err := nestedTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lomap/internal/generate/nested/nested.gotmpl b/lomap/internal/generate/nested/nested.gotmpl
new file mode 100644
index 00000000..9dae6c53
--- /dev/null
+++ b/lomap/internal/generate/nested/nested.gotmpl
@@ -0,0 +1,25 @@
+{{- define "decls-types" -}}{{ $N := .N }}
+	{{- range $i := .N }}
+		{{- if ne $i 0 }}, {{ end -}}
+		M{{ add $i 1 }} ~map[K{{ add $i 1}}]
+		{{- if eq $N (add $i 1) }}T{{ else }}M{{ add $i 2 }}{{ end -}}
+	{{- end }}
+	{{- range $i := .N }}, K{{ add $i 1 }}{{ end }} comparable
+{{- end }}
+{{- define "decls-args" -}}
+m1 M1{{ range $i := .N }}, k{{ add $i 1 }} K{{ add $i 1 }}{{ end }}
+{{- end }}
+func Nested{{ .N }}[{{ template "decls-types" . }}, T any](
+	{{ template "decls-args" . }},
+) (v T, ok bool) {
+
+	{{ range $i := (sub .N 1) -}}
+	m{{ add $i 2 }}, ok := m{{ add $i 1 }}[k{{ add $i 1 }}]
+	if !ok {
+		return
+	}
+
+	{{ end -}}
+	v, ok = m{{ .N }}[k{{ .N }}]
+	return
+}
diff --git a/lomap/logic.go b/lomap/logic.go
new file mode 100644
index 00000000..c6bf34f4
--- /dev/null
+++ b/lomap/logic.go
@@ -0,0 +1,132 @@
+package lomap
+
+import "github.com/samber/lo/loslice"
+
+func ContainsVal[Map ~map[K]V, K, V comparable](m Map, v V) bool {
+	for _, val := range m {
+		if val == v {
+			return true
+		}
+	}
+
+	return false
+}
+
+func WithoutVal[Map ~map[K]V, K, V comparable](m Map, v V) bool {
+	return !ContainsVal(m, v)
+}
+
+func ContainsKey[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) bool {
+	for k := range m {
+		if pred(k) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func WithoutKeyPred[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) bool {
+	return !ContainsKey(m, pred)
+}
+
+func Contains[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) bool {
+	for _, v := range m {
+		if pred(v) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func Without[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) bool {
+	return !Contains(m, pred)
+}
+
+func KContains[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) bool {
+	for k, v := range m {
+		if pred(k, v) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func KWithout[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) bool {
+	return !KContains(m, pred)
+}
+
+func EveryVal[Map ~map[K]V, K, V comparable](m Map, v V) bool {
+	for _, val := range m {
+		if val != v {
+			return false
+		}
+	}
+
+	return true
+}
+
+func EveryKey[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) bool {
+	for k := range m {
+		if !pred(k) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func Every[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) bool {
+	for _, v := range m {
+		if !pred(v) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func KEvery[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) bool {
+	for k, v := range m {
+		if !pred(k, v) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func Disjoint[Map ~map[K]V, K comparable, V any](a, b Map) bool {
+	if len(b) < len(a) {
+		a, b = b, a // Ensure a is the smaller map
+	}
+
+	for k := range a {
+		if _, exists := b[k]; exists {
+			return false
+		}
+	}
+
+	return true
+}
+
+func GroupDisjoint[Map ~map[K]V, K comparable, V any](ms ...Map) bool {
+	if len(ms) == 0 || loslice.Every(ms, IsEmpty) {
+		return true
+	}
+
+	seen := make(map[K]struct{}, loslice.MapSum(ms, Len))
+
+	for _, m := range ms {
+		for k := range m {
+			if _, exists := seen[k]; exists {
+				return false // Found a duplicate key
+			}
+			seen[k] = struct{}{} // Mark the key as seen
+		}
+	}
+
+	return true
+}
diff --git a/lomap/map.go b/lomap/map.go
new file mode 100644
index 00000000..9915103c
--- /dev/null
+++ b/lomap/map.go
@@ -0,0 +1,29 @@
+package lomap
+
+func Enumerate[Map ~map[K]V, K comparable, V any](m Map) (indices map[K]int) {
+	indices = make(map[K]int, len(m))
+	i := 0
+	for k := range m {
+		indices[k] = i
+		i++
+	}
+
+	return indices
+}
+
+func Swap[Map ~map[K]V, K, V comparable](m Map) (swapped map[V]K) {
+	swapped = make(map[V]K, len(m))
+	for k, v := range m {
+		swapped[v] = k
+	}
+
+	return swapped
+}
+
+func Any[Map ~map[K]V, K comparable, V any](m Map) (k K, v V) {
+	for k, v = range m {
+		return k, v
+	}
+
+	return
+}
diff --git a/lomap/min_n_max.go b/lomap/min_n_max.go
new file mode 100644
index 00000000..d9576462
--- /dev/null
+++ b/lomap/min_n_max.go
@@ -0,0 +1,254 @@
+package lomap
+
+import (
+	"cmp"
+	"github.com/samber/lo/lotup"
+)
+
+func MinKey[Map ~map[K]V, K cmp.Ordered, V any](m Map) K {
+	if len(m) == 0 {
+		var zero K
+		return zero
+	}
+
+	res := lotup.First(Any(m))
+	for k := range m {
+		if k < res {
+			res = k
+		}
+	}
+
+	return res
+}
+
+func MinVal[Map ~map[K]V, K comparable, V cmp.Ordered](m Map) V {
+	if len(m) == 0 {
+		var zero V
+		return zero
+	}
+
+	res := lotup.Second(Any(m))
+	for _, v := range m {
+		if v < res {
+			res = v
+		}
+	}
+
+	return res
+}
+
+func ArgMinVal[Map ~map[K]V, K comparable, V cmp.Ordered](m Map) K {
+	if len(m) == 0 {
+		var zero K
+		return zero
+	}
+
+	key, res := Any(m)
+	for k, v := range m {
+		if v < res {
+			key, res = k, v
+		}
+	}
+
+	return key
+}
+
+func Min[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, frank func(V) R) (V, R) {
+	if len(m) == 0 {
+		var zero V
+		var zeroR R
+		return zero, zeroR
+	}
+
+	val := lotup.Second(Any(m))
+	rank := frank(val)
+	for _, v := range m {
+		r := frank(v)
+		if r < rank {
+			val, rank = v, r
+		}
+	}
+
+	return val, rank
+}
+
+func ArgMin[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, frank func(V) R) (K, R) {
+	if len(m) == 0 {
+		var zero K
+		var zeroR R
+		return zero, zeroR
+	}
+
+	key, v := Any(m)
+	rank := frank(v)
+	for k, v := range m {
+		r := frank(v)
+		if r < rank {
+			key, rank = k, r
+		}
+	}
+
+	return key, rank
+}
+
+func KMin[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, krank func(K, V) R) (V, R) {
+	if len(m) == 0 {
+		var zero V
+		var zeroR R
+		return zero, zeroR
+	}
+
+	k, val := Any(m)
+	rank := krank(k, val)
+	for k, v := range m {
+		r := krank(k, v)
+		if r < rank {
+			val, rank = v, r
+		}
+	}
+
+	return val, rank
+}
+
+func KArgMin[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, krank func(K, V) R) (K, R) {
+	if len(m) == 0 {
+		var zero K
+		var zeroR R
+		return zero, zeroR
+	}
+
+	key, v := Any(m)
+	rank := krank(key, v)
+	for k, v := range m {
+		r := krank(k, v)
+		if r < rank {
+			key, rank = k, r
+		}
+	}
+
+	return key, rank
+}
+
+func MaxKey[Map ~map[K]V, K cmp.Ordered, V any](m Map) K {
+	if len(m) == 0 {
+		var zero K
+		return zero
+	}
+
+	res := lotup.First(Any(m))
+	for k := range m {
+		if k > res {
+			res = k
+		}
+	}
+
+	return res
+}
+
+func MaxVal[Map ~map[K]V, K comparable, V cmp.Ordered](m Map) V {
+	if len(m) == 0 {
+		var zero V
+		return zero
+	}
+
+	res := lotup.Second(Any(m))
+	for _, v := range m {
+		if v > res {
+			res = v
+		}
+	}
+
+	return res
+}
+
+func ArgMaxVal[Map ~map[K]V, K comparable, V cmp.Ordered](m Map) K {
+	if len(m) == 0 {
+		var zero K
+		return zero
+	}
+
+	key, res := Any(m)
+	for k, v := range m {
+		if v > res {
+			key, res = k, v
+		}
+	}
+
+	return key
+}
+
+func Max[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, frank func(V) R) (V, R) {
+	if len(m) == 0 {
+		var zero V
+		var zeroR R
+		return zero, zeroR
+	}
+
+	val := lotup.Second(Any(m))
+	rank := frank(val)
+	for _, v := range m {
+		r := frank(v)
+		if r > rank {
+			val, rank = v, r
+		}
+	}
+
+	return val, rank
+}
+
+func ArgMax[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, frank func(V) R) (K, R) {
+	if len(m) == 0 {
+		var zero K
+		var zeroR R
+		return zero, zeroR
+	}
+
+	key, v := Any(m)
+	rank := frank(v)
+	for k, v := range m {
+		r := frank(v)
+		if r > rank {
+			key, rank = k, r
+		}
+	}
+
+	return key, rank
+}
+
+func KMax[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, krank func(K, V) R) (V, R) {
+	if len(m) == 0 {
+		var zero V
+		var zeroR R
+		return zero, zeroR
+	}
+
+	k, val := Any(m)
+	rank := krank(k, val)
+	for k, v := range m {
+		r := krank(k, v)
+		if r > rank {
+			val, rank = v, r
+		}
+	}
+
+	return val, rank
+}
+
+func KArgMax[Map ~map[K]V, K comparable, V any, R cmp.Ordered](m Map, krank func(K, V) R) (K, R) {
+	if len(m) == 0 {
+		var zero K
+		var zeroR R
+		return zero, zeroR
+	}
+
+	key, v := Any(m)
+	rank := krank(key, v)
+	for k, v := range m {
+		r := krank(k, v)
+		if r > rank {
+			key, rank = k, r
+		}
+	}
+
+	return key, rank
+}
diff --git a/lomap/monad.go b/lomap/monad.go
new file mode 100644
index 00000000..86c49538
--- /dev/null
+++ b/lomap/monad.go
@@ -0,0 +1,294 @@
+package lomap
+
+import (
+	"github.com/samber/lo/loslice"
+	"maps"
+	"slices"
+)
+
+func IsNil[Map ~map[K]V, K comparable, V any](m Map) bool {
+	return m == nil
+}
+
+func IsEmpty[Map ~map[K]V, K comparable, V any](m Map) bool {
+	return len(m) == 0
+}
+
+func Len[Map ~map[K]V, K comparable, V any](m Map) int {
+	return len(m)
+}
+
+func MapValues[Map ~map[K]V, K comparable, V, R any](m Map, fmap func(V) R) map[K]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[K]R, len(m))
+	for k, v := range m {
+		result[k] = fmap(v)
+	}
+
+	return result
+}
+
+func MapKeys[Map ~map[K]V, K comparable, V, R any](m Map, fmap func(K) R) map[K]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[K]R, len(m))
+	for k := range m {
+		result[k] = fmap(k)
+	}
+
+	return result
+}
+
+func MapPairs[Map ~map[K]V, K comparable, V, R any](m Map, fmap func(K, V) R) map[K]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[K]R, len(m))
+	for k, v := range m {
+		result[k] = fmap(k, v)
+	}
+
+	return result
+}
+
+func FullMap[Map ~map[K]V, K, Q comparable, V, R any](m Map, fmap func(K, V) (Q, R)) map[Q]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[Q]R, len(m))
+	for k, v := range m {
+		q, r := fmap(k, v)
+		result[q] = r
+	}
+
+	return result
+}
+
+func FilterMapValues[Map ~map[K]V, K comparable, V, R any](m Map, fmap func(V) (R, bool)) map[K]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[K]R, len(m))
+	for k, v := range m {
+		if r, ok := fmap(v); ok {
+			result[k] = r
+		}
+	}
+
+	return result
+}
+
+func FilterMapKeys[Map ~map[K]V, K comparable, V, R any](m Map, fmap func(K) (R, bool)) map[K]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[K]R, len(m))
+	for k := range m {
+		if r, ok := fmap(k); ok {
+			result[k] = r
+		}
+	}
+
+	return result
+}
+
+func FilterMapPairs[Map ~map[K]V, K comparable, V, R any](m Map, fmap func(K, V) (R, bool)) map[K]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[K]R, len(m))
+	for k, v := range m {
+		if r, ok := fmap(k, v); ok {
+			result[k] = r
+		}
+	}
+
+	return result
+}
+
+func FilterFullMap[Map ~map[K]V, K, Q comparable, V, R any](m Map, fmap func(K, V) (Q, R, bool)) map[Q]R {
+	if m == nil {
+		return nil
+	}
+
+	result := make(map[Q]R, len(m))
+	for k, v := range m {
+		q, r, ok := fmap(k, v)
+		if ok {
+			result[q] = r
+		}
+	}
+
+	return result
+}
+
+func Merge[Map ~map[K]V, K comparable, V any](a, b Map) Map {
+	if a == nil && b == nil {
+		return nil
+	} else if a == nil {
+		return maps.Clone(b)
+	} else if b == nil {
+		return maps.Clone(a)
+	}
+
+	result := make(Map, len(a)+len(b))
+	maps.Copy(result, a)
+	maps.Copy(result, b)
+
+	return result
+}
+
+func GroupMerge[Map ~map[K]V, K comparable, V any](ms ...Map) Map {
+	if len(ms) == 0 || loslice.Every(ms, IsNil) {
+		return nil
+	}
+
+	result := make(Map, loslice.MapSum(ms, Len))
+	for _, m := range ms {
+		maps.Copy(result, m)
+	}
+
+	return result
+}
+
+func Common[Map ~map[K]V, K comparable, V any](a, b Map) (ia Map, ib Map) {
+	if a == nil || b == nil {
+		return nil, nil
+	}
+
+	swapped := false
+	if len(b) < len(a) {
+		swapped = true
+		a, b = b, a // Ensure a is the smaller map
+	}
+
+	ia, ib = make(Map, len(a)), make(Map, len(a))
+	for k, va := range a {
+		if vb, ok := b[k]; ok {
+			ia[k] = va
+			ib[k] = vb
+		}
+	}
+
+	if swapped {
+		ia, ib = ib, ia // Swap back if we swapped a and b
+	}
+
+	return
+}
+
+func GroupCommon[Map ~map[K]V, K comparable, V any](maps ...Map) map[K][]V {
+	if len(maps) == 0 || loslice.Every(maps, IsNil) {
+		return nil
+	}
+
+	// Find the smallest map to reduce iterations
+	smallest, size := loslice.Min(maps, Len)
+
+	if size == 0 {
+		return make(map[K][]V)
+	}
+
+	intersection := make(map[K][]V, size)
+	alternatives := make([]V, 0, len(maps))
+
+keysLoop:
+	for k := range smallest {
+		alternatives = alternatives[:0] // Reset alternatives for each key
+		for _, m := range maps {
+			if v, ok := m[k]; ok {
+				alternatives = append(alternatives, v)
+			} else {
+				continue keysLoop // If any map does not have the key, skip to the next key
+			}
+		}
+
+		intersection[k] = slices.Clone(alternatives)
+	}
+
+	return intersection
+}
+
+func Distinct[Map ~map[K]V, K comparable, V any](a, b Map) Map {
+	if a == nil && b == nil {
+		return nil
+	} else if a == nil {
+		return maps.Clone(b)
+	} else if b == nil {
+		return maps.Clone(a)
+	}
+
+	if len(a) < len(b) {
+		// swap a and b to ensure b is the smaller map
+		a, b = b, a
+	}
+
+	result := make(Map, len(a)+len(b))
+	maps.Copy(result, a) // clone larger map
+
+	for k := range b { // iterate over smaller map
+		if _, exists := result[k]; exists {
+			delete(result, k)
+		} else {
+			result[k] = b[k]
+		}
+	}
+
+	return result
+}
+
+func GroupDistinct[Map ~map[K]V, K comparable, V any](ms ...Map) Map {
+	if len(ms) == 0 || loslice.Every(ms, IsNil) {
+		return nil
+	}
+
+	size := loslice.MapSum(ms, Len)
+	result := make(Map, size)
+	seen := make(map[K]struct{}, size)
+	for _, m := range ms {
+		for k, v := range m {
+			if _, exists := seen[k]; exists {
+				continue // Skip if the key has already been seen
+			} else if _, exists := result[k]; exists {
+				// If the key exists in the result, delete it from the result
+				// and mark it as seen to avoid duplicates
+				delete(result, k)
+				seen[k] = struct{}{}
+			} else {
+				result[k] = v
+			}
+		}
+	}
+
+	return result
+}
+
+// Unique returns a new map containing keys from `a` that are not present in `b`.
+func Unique[Map ~map[K]V, K comparable, V any](a, b Map) Map {
+	if a == nil && b == nil {
+		return nil
+	} else if a == nil {
+		return maps.Clone(b)
+	} else if b == nil {
+		return maps.Clone(a)
+	}
+
+	result := make(Map, len(a))
+	for k := range a {
+		if _, exists := b[k]; !exists {
+			result[k] = a[k] // Add only keys from a that are not in b
+		}
+	}
+
+	return result
+}
diff --git a/lomap/nested.go b/lomap/nested.go
new file mode 100644
index 00000000..07f2a616
--- /dev/null
+++ b/lomap/nested.go
@@ -0,0 +1,248 @@
+// Code generated by generate_nested.go; DO NOT EDIT.
+package lomap
+
+//go:generate go run internal/generate/nested/generate_nested.go
+
+func Nested2[M1 ~map[K1]M2, M2 ~map[K2]T, K1, K2 comparable, T any](
+	m1 M1, k1 K1, k2 K2,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	v, ok = m2[k2]
+	return
+}
+
+func Nested3[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]T, K1, K2, K3 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	v, ok = m3[k3]
+	return
+}
+
+func Nested4[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]M4, M4 ~map[K4]T, K1, K2, K3, K4 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3, k4 K4,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	m4, ok := m3[k3]
+	if !ok {
+		return
+	}
+
+	v, ok = m4[k4]
+	return
+}
+
+func Nested5[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]M4, M4 ~map[K4]M5, M5 ~map[K5]T, K1, K2, K3, K4, K5 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3, k4 K4, k5 K5,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	m4, ok := m3[k3]
+	if !ok {
+		return
+	}
+
+	m5, ok := m4[k4]
+	if !ok {
+		return
+	}
+
+	v, ok = m5[k5]
+	return
+}
+
+func Nested6[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]M4, M4 ~map[K4]M5, M5 ~map[K5]M6, M6 ~map[K6]T, K1, K2, K3, K4, K5, K6 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3, k4 K4, k5 K5, k6 K6,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	m4, ok := m3[k3]
+	if !ok {
+		return
+	}
+
+	m5, ok := m4[k4]
+	if !ok {
+		return
+	}
+
+	m6, ok := m5[k5]
+	if !ok {
+		return
+	}
+
+	v, ok = m6[k6]
+	return
+}
+
+func Nested7[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]M4, M4 ~map[K4]M5, M5 ~map[K5]M6, M6 ~map[K6]M7, M7 ~map[K7]T, K1, K2, K3, K4, K5, K6, K7 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3, k4 K4, k5 K5, k6 K6, k7 K7,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	m4, ok := m3[k3]
+	if !ok {
+		return
+	}
+
+	m5, ok := m4[k4]
+	if !ok {
+		return
+	}
+
+	m6, ok := m5[k5]
+	if !ok {
+		return
+	}
+
+	m7, ok := m6[k6]
+	if !ok {
+		return
+	}
+
+	v, ok = m7[k7]
+	return
+}
+
+func Nested8[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]M4, M4 ~map[K4]M5, M5 ~map[K5]M6, M6 ~map[K6]M7, M7 ~map[K7]M8, M8 ~map[K8]T, K1, K2, K3, K4, K5, K6, K7, K8 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3, k4 K4, k5 K5, k6 K6, k7 K7, k8 K8,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	m4, ok := m3[k3]
+	if !ok {
+		return
+	}
+
+	m5, ok := m4[k4]
+	if !ok {
+		return
+	}
+
+	m6, ok := m5[k5]
+	if !ok {
+		return
+	}
+
+	m7, ok := m6[k6]
+	if !ok {
+		return
+	}
+
+	m8, ok := m7[k7]
+	if !ok {
+		return
+	}
+
+	v, ok = m8[k8]
+	return
+}
+
+func Nested9[M1 ~map[K1]M2, M2 ~map[K2]M3, M3 ~map[K3]M4, M4 ~map[K4]M5, M5 ~map[K5]M6, M6 ~map[K6]M7, M7 ~map[K7]M8, M8 ~map[K8]M9, M9 ~map[K9]T, K1, K2, K3, K4, K5, K6, K7, K8, K9 comparable, T any](
+	m1 M1, k1 K1, k2 K2, k3 K3, k4 K4, k5 K5, k6 K6, k7 K7, k8 K8, k9 K9,
+) (v T, ok bool) {
+
+	m2, ok := m1[k1]
+	if !ok {
+		return
+	}
+
+	m3, ok := m2[k2]
+	if !ok {
+		return
+	}
+
+	m4, ok := m3[k3]
+	if !ok {
+		return
+	}
+
+	m5, ok := m4[k4]
+	if !ok {
+		return
+	}
+
+	m6, ok := m5[k5]
+	if !ok {
+		return
+	}
+
+	m7, ok := m6[k6]
+	if !ok {
+		return
+	}
+
+	m8, ok := m7[k7]
+	if !ok {
+		return
+	}
+
+	m9, ok := m8[k8]
+	if !ok {
+		return
+	}
+
+	v, ok = m9[k9]
+	return
+}
diff --git a/lomap/parts.go b/lomap/parts.go
new file mode 100644
index 00000000..0852c6e4
--- /dev/null
+++ b/lomap/parts.go
@@ -0,0 +1,41 @@
+package lomap
+
+import "github.com/samber/lo/lotup"
+
+func Keys[Map ~map[K]V, K comparable, V any](m Map) (keys []K) {
+	keys = make([]K, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+
+	return keys
+}
+
+func Values[Map ~map[K]V, K comparable, V any](m Map) (values []V) {
+	values = make([]V, 0, len(m))
+	for _, v := range m {
+		values = append(values, v)
+	}
+
+	return values
+}
+
+func Pairs[Map ~map[K]V, K comparable, V any](m Map) (pairs []lotup.Tuple2[K, V]) {
+	pairs = make([]lotup.Tuple2[K, V], 0, len(m))
+	for k, v := range m {
+		pairs = append(pairs, lotup.Of2(k, v))
+	}
+
+	return pairs
+}
+
+func Unzip[Map ~map[K]V, K comparable, V any](m Map) (keys []K, values []V) {
+	keys = make([]K, 0, len(m))
+	values = make([]V, 0, len(m))
+	for k, v := range m {
+		keys = append(keys, k)
+		values = append(values, v)
+	}
+
+	return keys, values
+}
diff --git a/lomap/split.go b/lomap/split.go
new file mode 100644
index 00000000..92645660
--- /dev/null
+++ b/lomap/split.go
@@ -0,0 +1,46 @@
+package lomap
+
+func SplitKeys[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) (taken, rest Map) {
+	taken = make(Map, len(m))
+	rest = make(Map, len(m))
+
+	for k, v := range m {
+		if pred(k) {
+			taken[k] = v
+		} else {
+			rest[k] = v
+		}
+	}
+
+	return taken, rest
+}
+
+func SplitValues[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) (taken, rest Map) {
+	taken = make(Map, len(m))
+	rest = make(Map, len(m))
+
+	for k, v := range m {
+		if pred(v) {
+			taken[k] = v
+		} else {
+			rest[k] = v
+		}
+	}
+
+	return taken, rest
+}
+
+func SplitPairs[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) (taken, rest Map) {
+	taken = make(Map, len(m))
+	rest = make(Map, len(m))
+
+	for k, v := range m {
+		if pred(k, v) {
+			taken[k] = v
+		} else {
+			rest[k] = v
+		}
+	}
+
+	return taken, rest
+}
diff --git a/loset/mutation.go b/loset/mutation.go
new file mode 100644
index 00000000..bf94c73f
--- /dev/null
+++ b/loset/mutation.go
@@ -0,0 +1,62 @@
+package loset
+
+import (
+	"github.com/samber/lo/lomap"
+	"github.com/samber/lo/loslice"
+	"github.com/samber/lo/mutmap"
+	"maps"
+)
+
+func KeepCommon[S ~Set[T], T comparable](self, other S, more ...S) {
+	if len(other) == 0 || loslice.Contains(more, lomap.IsEmpty) {
+		mutmap.Clear(self) // Clear the set if the other set is empty or if any of the additional sets are empty
+		return
+	}
+
+	for k := range self {
+		if _, ok := other[k]; !ok {
+			delete(self, k)
+		}
+	}
+
+	if len(more) == 0 {
+		return // If no additional sets are provided, we are done
+	}
+
+	for k := range self {
+		for _, s := range more {
+			if _, ok := s[k]; !ok {
+				delete(self, k)
+				break
+			}
+		}
+	}
+}
+
+func Subtract[S ~Set[T], T comparable](self, other S, more ...S) {
+	for k := range self {
+		if _, ok := other[k]; ok {
+			delete(self, k)
+		}
+	}
+
+	if len(more) == 0 || loslice.Every(more, lomap.IsEmpty) {
+		return // If no additional sets are provided, or they have no elements, we are done
+	}
+
+	for k := range self {
+		for _, s := range more {
+			if _, ok := s[k]; ok {
+				delete(self, k)
+				break
+			}
+		}
+	}
+}
+
+func Add[S ~Set[T], T comparable](self, other S, more ...S) {
+	maps.Copy(self, other)
+	for _, s := range more {
+		maps.Copy(self, s)
+	}
+}
diff --git a/loset/operations.go b/loset/operations.go
new file mode 100644
index 00000000..d108daf0
--- /dev/null
+++ b/loset/operations.go
@@ -0,0 +1,125 @@
+package loset
+
+import (
+	"github.com/samber/lo/loslice"
+	"github.com/samber/lo/lotup"
+	"maps"
+)
+
+func Intersection[S ~Set[T], T comparable](a, b S) (intersection S) {
+	if len(b) < len(a) {
+		// swap a and b to ensure a is the smaller set
+		a, b = b, a
+	}
+
+	intersection = make(S, len(a))
+	for k := range a {
+		if _, ok := b[k]; ok {
+			intersection[k] = struct{}{}
+		}
+	}
+
+	return
+}
+
+func GroupIntersection[S ~Set[T], T comparable](sets ...S) (intersection S) {
+	if len(sets) == 0 {
+		return nil
+	}
+
+	// look for the smallest set to reduce iterations
+	i := lotup.First(loslice.ArgMin(sets, func(s S) int { return len(s) }))
+	intersection = maps.Clone(sets[i])
+
+	copy(sets[i:], sets[i+1:])
+	sets = sets[:len(sets)-1]
+
+	for it := range intersection {
+		for _, set := range sets {
+			if _, ok := set[it]; !ok {
+				delete(intersection, it)
+				break
+			}
+		}
+	}
+
+	return intersection
+}
+
+func Union[S ~Set[T], T comparable](a, b S) (union S) {
+	if len(b) > len(a) {
+		// swap a and b to ensure a is the larger set
+		a, b = b, a
+	}
+
+	union = maps.Clone(a)
+	maps.Copy(union, b)
+
+	return union
+}
+
+func GroupUnion[S ~Set[T], T comparable](sets ...S) (union S) {
+	if len(sets) == 0 {
+		return nil
+	}
+
+	union = make(S)
+	for _, set := range sets {
+		maps.Copy(union, set)
+	}
+
+	return union
+}
+
+func Difference[S ~Set[T], T comparable](a, b S) (difference S) {
+	difference = make(S, len(a))
+	for k := range a {
+		if _, ok := b[k]; !ok {
+			difference[k] = struct{}{}
+		}
+	}
+
+	return
+}
+
+func SymmetricDifference[S ~Set[T], T comparable](a, b S) (symmetricDifference S) {
+	if len(b) > len(a) {
+		// swap a and b to ensure a is the larger set
+		a, b = b, a
+	}
+
+	symmetricDifference = maps.Clone(a)
+
+	for k := range b {
+		if _, ok := a[k]; ok {
+			delete(symmetricDifference, k)
+		} else {
+			symmetricDifference[k] = struct{}{}
+		}
+	}
+
+	return symmetricDifference
+}
+
+func GroupSymmetricDifference[S ~Set[T], T comparable](sets ...S) (symmetricDifference S) {
+	if len(sets) == 0 {
+		return nil
+	}
+
+	rejected := make(S)
+	symmetricDifference = make(S)
+	for _, s := range sets {
+		for k := range s {
+			if _, ok := rejected[k]; ok {
+				continue
+			} else if _, ok := symmetricDifference[k]; ok {
+				rejected[k] = struct{}{}
+				delete(symmetricDifference, k)
+			} else {
+				symmetricDifference[k] = struct{}{}
+			}
+		}
+	}
+
+	return symmetricDifference
+}
diff --git a/loset/set.go b/loset/set.go
new file mode 100644
index 00000000..5afe3780
--- /dev/null
+++ b/loset/set.go
@@ -0,0 +1,35 @@
+package loset
+
+import "iter"
+
+type Set[T comparable] = map[T]struct{}
+
+func FromSlice[Slice ~[]T, T comparable](xs Slice) Set[T] {
+	set := make(Set[T], len(xs))
+
+	for _, x := range xs {
+		set[x] = struct{}{}
+	}
+
+	return set
+}
+
+func Collect[T comparable, Seq iter.Seq[T]](xs Seq) Set[T] {
+	set := make(Set[T])
+
+	for x := range xs {
+		set[x] = struct{}{}
+	}
+
+	return set
+}
+
+func ToSlice[S ~Set[T], T comparable](set S) []T {
+	slice := make([]T, 0, len(set))
+
+	for x := range set {
+		slice = append(slice, x)
+	}
+
+	return slice
+}
diff --git a/loslice/arithm.go b/loslice/arithm.go
new file mode 100644
index 00000000..94d86a4f
--- /dev/null
+++ b/loslice/arithm.go
@@ -0,0 +1,143 @@
+package loslice
+
+type Number interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
+		~float32 | ~float64 |
+		~complex64 | ~complex128
+}
+
+func Sum[Slice ~[]T, T Number](xs Slice) (sum T) {
+	for _, x := range xs {
+		sum += x
+	}
+
+	return sum
+}
+
+func Product[Slice ~[]T, T Number](xs Slice) (prod T) {
+	prod = 1
+	for _, x := range xs {
+		prod *= x
+	}
+
+	return prod
+}
+
+func FilterSum[Slice ~[]T, T Number](xs Slice, pred func(T) bool) (sum T) {
+	for _, x := range xs {
+		if pred(x) {
+			sum += x
+		}
+	}
+
+	return sum
+}
+
+func FilterProduct[Slice ~[]T, T Number](xs Slice, pred func(T) bool) (prod T) {
+	prod = 1
+	for _, x := range xs {
+		if pred(x) {
+			prod *= x
+		}
+	}
+
+	return prod
+}
+
+func IFilterSum[Slice ~[]T, T Number](xs Slice, ipred func(int, T) bool) (sum T) {
+	for i, x := range xs {
+		if ipred(i, x) {
+			sum += x
+		}
+	}
+
+	return sum
+}
+
+func IFilterProduct[Slice ~[]T, T Number](xs Slice, ipred func(int, T) bool) (prod T) {
+	prod = 1
+	for i, x := range xs {
+		if ipred(i, x) {
+			prod *= x
+		}
+	}
+
+	return prod
+}
+
+func MapSum[Slice ~[]T, T any, V Number](xs Slice, fmap func(T) V) (sum V) {
+	for _, x := range xs {
+		sum += fmap(x)
+	}
+
+	return sum
+}
+
+func MapProduct[Slice ~[]T, T any, V Number](xs Slice, fmap func(T) V) (prod V) {
+	prod = 1
+	for _, x := range xs {
+		prod *= fmap(x)
+	}
+
+	return prod
+}
+
+func IMapSum[Slice ~[]T, T any, V Number](xs Slice, imap func(int, T) V) (sum V) {
+	for i, x := range xs {
+		sum += imap(i, x)
+	}
+
+	return sum
+}
+
+func IMapProduct[Slice ~[]T, T any, V Number](xs Slice, imap func(int, T) V) (prod V) {
+	prod = 1
+	for i, x := range xs {
+		prod *= imap(i, x)
+	}
+
+	return prod
+}
+
+func FilterMapSum[Slice ~[]T, T any, V Number](xs Slice, fmap func(T) (V, bool)) (sum V) {
+	for _, x := range xs {
+		if v, ok := fmap(x); ok {
+			sum += v
+		}
+	}
+
+	return sum
+}
+
+func FilterMapProduct[Slice ~[]T, T any, V Number](xs Slice, fmap func(T) (V, bool)) (prod V) {
+	prod = 1
+	for _, x := range xs {
+		if v, ok := fmap(x); ok {
+			prod *= v
+		}
+	}
+
+	return prod
+}
+
+func IFilterMapSum[Slice ~[]T, T any, V Number](xs Slice, imap func(int, T) (V, bool)) (sum V) {
+	for i, x := range xs {
+		if v, ok := imap(i, x); ok {
+			sum += v
+		}
+	}
+
+	return sum
+}
+
+func IFilterMapProduct[Slice ~[]T, T any, V Number](xs Slice, imap func(int, T) (V, bool)) (prod V) {
+	prod = 1
+	for i, x := range xs {
+		if v, ok := imap(i, x); ok {
+			prod *= v
+		}
+	}
+
+	return prod
+}
diff --git a/loslice/constructor.go b/loslice/constructor.go
new file mode 100644
index 00000000..8252f1d5
--- /dev/null
+++ b/loslice/constructor.go
@@ -0,0 +1,86 @@
+package loslice
+
+// Repeat returns a slice containing the items repeated n times in cyclic order.
+func Repeat[T any](n int, items ...T) []T {
+	if n <= 0 {
+		return nil
+	}
+
+	k := len(items)
+	result := make([]T, n*k)
+
+	if k > 1 {
+		for i := range result {
+			result[i] = items[i%k]
+		}
+	} else {
+		it := items[0]
+		for i := range result {
+			result[i] = it
+		}
+	}
+
+	return result
+}
+
+// Times returns a slice where each item from `items` is repeated `n` times.
+func Times[T any](n int, items ...T) []T {
+	if n <= 0 {
+		return nil
+	}
+
+	k := len(items)
+	result := make([]T, n*k)
+
+	if k > 1 {
+		for i := range k {
+			for j := range n {
+				result[i*n+j] = items[i]
+			}
+		}
+	} else {
+		it := items[0]
+		for i := range result {
+			result[i] = it
+		}
+	}
+
+	return result
+}
+
+// Cycle returns a slice not the specified size, where the items are taken from the provided items in a cyclic manner.
+func Cycle[T any](size int, items ...T) []T {
+	if size <= 0 {
+		return nil
+	}
+
+	k := len(items)
+	result := make([]T, size)
+
+	if k > 1 {
+		for i := range result {
+			result[i] = items[i%k]
+		}
+	} else {
+		it := items[0]
+		for i := range result {
+			result[i] = it
+		}
+	}
+
+	return result
+}
+
+// Fill returns a slice not the specified size, where each item is generated by the provided function `iget`.
+func Fill[T any](size int, iget func(int) T) []T {
+	if size <= 0 {
+		return nil
+	}
+
+	result := make([]T, size)
+	for i := range result {
+		result[i] = iget(i)
+	}
+
+	return result
+}
diff --git a/loslice/count.go b/loslice/count.go
new file mode 100644
index 00000000..9e0e960f
--- /dev/null
+++ b/loslice/count.go
@@ -0,0 +1,34 @@
+package loslice
+
+// Count counts the number not elements in the collection for which predicate is true.
+func Count[Slice ~[]T, T any](xs Slice, pred func(T) bool) (count int) {
+	for _, x := range xs {
+		if pred(x) {
+			count++
+		}
+	}
+
+	return count
+}
+
+// ICount counts the number not elements in the collection for which predicate is true.
+func ICount[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (count int) {
+	for i, x := range xs {
+		if ipred(i, x) {
+			count++
+		}
+	}
+
+	return count
+}
+
+// CountVal counts the number not elements in the collection that compare equal to value.
+func CountVal[Slice ~[]T, T comparable](xs Slice, val T) (count int) {
+	for _, x := range xs {
+		if x == val {
+			count++
+		}
+	}
+
+	return count
+}
diff --git a/loslice/filter.go b/loslice/filter.go
new file mode 100644
index 00000000..a15c61be
--- /dev/null
+++ b/loslice/filter.go
@@ -0,0 +1,74 @@
+package loslice
+
+func RejectVal[Slice ~[]T, T comparable](xs Slice, val T) (result Slice) {
+	return rejectVal(xs, val, nil)
+}
+
+func RejectValEx[Slice ~[]T, T comparable](mode AllocateMode, xs Slice, val T) (result Slice) {
+	if xs == nil {
+		return nil
+	}
+
+	result = allocateCapacity[Slice](mode, len(xs), func() int { return len(xs) - CountVal(xs, val) })
+	return rejectVal(xs, val, result)
+}
+
+func rejectVal[Slice ~[]T, T comparable](xs Slice, val T, result Slice) Slice {
+	for _, x := range xs {
+		if x != val {
+			result = append(result, x)
+		}
+	}
+
+	return result
+}
+
+// Filter iterates over elements not collection, returning an array not all elements predicate returns truthy for.
+func Filter[Slice ~[]T, T any](xs Slice, pred func(item T) bool) Slice {
+	return filter(xs, pred, nil)
+}
+
+// FilterEx iterates over elements not collection, returning an array not all elements predicate returns truthy for.
+func FilterEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, pred func(item T) bool) Slice {
+	if xs == nil {
+		return nil
+	}
+
+	result := allocateCapacity[Slice](mode, len(xs), func() int { return Count(xs, pred) })
+	return filter(xs, pred, result)
+}
+
+func filter[Slice ~[]T, T any](xs Slice, pred func(item T) bool, result Slice) Slice {
+	for _, x := range xs {
+		if pred(x) {
+			result = append(result, x)
+		}
+	}
+
+	return result
+}
+
+// IFilter iterates over elements not collection, returning an array not all elements predicate returns truthy for.
+func IFilter[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) Slice {
+	return ifilter(xs, ipred, nil)
+}
+
+// IFilterEx iterates over elements not collection, returning an array not all elements predicate returns truthy for.
+func IFilterEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, ipred func(int, T) bool) Slice {
+	if xs == nil {
+		return nil
+	}
+
+	result := allocateCapacity[Slice](mode, len(xs), func() int { return ICount(xs, ipred) })
+	return ifilter(xs, ipred, result)
+}
+
+func ifilter[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool, result Slice) Slice {
+	for i, x := range xs {
+		if ipred(i, x) {
+			result = append(result, x)
+		}
+	}
+
+	return result
+}
diff --git a/loslice/find.go b/loslice/find.go
new file mode 100644
index 00000000..857f0c59
--- /dev/null
+++ b/loslice/find.go
@@ -0,0 +1,292 @@
+package loslice
+
+import "slices"
+
+func IndexVal[Slice ~[]T, T comparable](xs Slice, val T) (index int, ok bool) {
+	if i := slices.Index(xs, val); i >= 0 {
+		return i, true
+	}
+
+	return
+}
+
+func Index[Slice ~[]T, T any](xs Slice, pred func(item T) bool) (index int, ok bool) {
+	if i := slices.IndexFunc(xs, pred); i >= 0 {
+		return i, true
+	}
+
+	return
+}
+
+func IIndex[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (index int, ok bool) {
+	for i, x := range xs {
+		if ipred(i, x) {
+			return i, true
+		}
+	}
+
+	return
+}
+
+func RIndexVal[Slice ~[]T, T comparable](xs Slice, val T) (index int, ok bool) {
+	for i := len(xs) - 1; i >= 0; i-- {
+		if xs[i] == val {
+			return i, true
+		}
+	}
+
+	return
+}
+
+func RIndex[Slice ~[]T, T any](xs Slice, pred func(item T) bool) (index int, ok bool) {
+	for i := len(xs) - 1; i >= 0; i-- {
+		if pred(xs[i]) {
+			return i, true
+		}
+	}
+
+	return
+}
+
+func IRIndex[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (index int, ok bool) {
+	for i := len(xs) - 1; i >= 0; i-- {
+		if ipred(i, xs[i]) {
+			return i, true
+		}
+	}
+
+	return
+}
+
+func IndicesVal[Slice ~[]T, T comparable](xs Slice, val T) (indices []int) {
+	return indicesVal(xs, val, nil)
+}
+
+func IndicesValEx[Slice ~[]T, T comparable](mode AllocateMode, xs Slice, val T) (indices []int) {
+	if xs == nil {
+		return nil
+	}
+
+	indices = allocateCapacity[[]int](mode, len(xs), func() int { return CountVal(xs, val) })
+	return indicesVal(xs, val, indices)
+}
+
+func indicesVal[Slice ~[]T, T comparable](xs Slice, val T, indices []int) []int {
+	for i, x := range xs {
+		if x == val {
+			indices = append(indices, i)
+		}
+	}
+
+	return indices
+}
+
+func RIndicesVal[Slice ~[]T, T comparable](xs Slice, val T) (indices []int) {
+	indices = IndicesVal(xs, val)
+	slices.Reverse(indices)
+
+	return
+}
+
+func RIndicesValEx[Slice ~[]T, T comparable](mode AllocateMode, xs Slice, val T) (indices []int) {
+	indices = IndicesValEx(mode, xs, val)
+	slices.Reverse(indices)
+
+	return
+}
+
+// Indices returns indices of elements matching the predicate.
+func Indices[Slice ~[]T, T any](xs Slice, pred func(item T) bool) (indices []int) {
+	return indicesImpl(xs, pred, nil)
+}
+
+// IndicesEx returns indices of elements matching the predicate, with allocation mode.
+func IndicesEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, pred func(item T) bool) (indices []int) {
+	if xs == nil {
+		return nil
+	}
+
+	indices = allocateCapacity[[]int](mode, len(xs), func() int { return Count(xs, pred) })
+	return indicesImpl(xs, pred, indices)
+}
+
+// Helper for Indices and IndicesEx.
+func indicesImpl[Slice ~[]T, T any](xs Slice, pred func(item T) bool, indices []int) []int {
+	for i, x := range xs {
+		if pred(x) {
+			indices = append(indices, i)
+		}
+	}
+	return indices
+}
+
+func RIndices[Slice ~[]T, T any](xs Slice, pred func(item T) bool) (indices []int) {
+	indices = Indices(xs, pred)
+	slices.Reverse(indices)
+
+	return
+}
+
+// RIndicesEx returns indices of elements matching the predicate, with allocation mode.
+func RIndicesEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, pred func(item T) bool) (indices []int) {
+	indices = IndicesEx(mode, xs, pred)
+	slices.Reverse(indices)
+
+	return
+}
+
+// IIndices returns indices of elements matching the indexed predicate.
+func IIndices[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (indices []int) {
+	return iindices(xs, ipred, nil)
+}
+
+// IIndicesEx returns indices of elements matching the indexed predicate, with allocation mode.
+func IIndicesEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, ipred func(int, T) bool) (indices []int) {
+	if xs == nil {
+		return nil
+	}
+
+	indices = allocateCapacity[[]int](mode, len(xs), func() int { return ICount(xs, ipred) })
+	return iindices(xs, ipred, indices)
+}
+
+// Helper for IIndices and IIndicesEx.
+func iindices[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool, indices []int) []int {
+	for i, x := range xs {
+		if ipred(i, x) {
+			indices = append(indices, i)
+		}
+	}
+
+	return indices
+}
+
+func IRIndices[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (indices []int) {
+	indices = IIndices(xs, ipred)
+	slices.Reverse(indices)
+
+	return
+}
+
+// IRIndicesEx returns indices of elements matching the indexed predicate, with allocation mode.
+func IRIndicesEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, ipred func(int, T) bool) (indices []int) {
+	indices = IIndicesEx(mode, xs, ipred)
+	slices.Reverse(indices)
+
+	return
+}
+
+// IndicesNVal returns the first n indices of the value in the slice.
+// Supports negative n to get the last n indices.
+func IndicesNVal[Slice ~[]T, T comparable](xs Slice, n int, val T) (indices []int) {
+	if xs == nil {
+		return nil
+	}
+
+	if n == 0 {
+		return IndicesVal(xs, val)
+	}
+
+	if n > 0 {
+		if n >= len(xs) {
+			return IndicesVal(xs, val)
+		}
+
+		indices = make([]int, 0, n)
+		for i := 0; i < len(xs) && len(indices) < n; i++ {
+			if xs[i] == val {
+				indices = append(indices, i)
+			}
+		}
+	} else {
+		n = -n
+		if n >= len(xs) {
+			return RIndicesVal(xs, val)
+		}
+
+		indices = make([]int, 0, n)
+		for i := len(xs) - 1; i >= 0 && len(indices) < n; i-- {
+			if xs[i] == val {
+				indices = append(indices, i)
+			}
+		}
+	}
+
+	return
+}
+
+// IndicesN returns the first n indices of the elements that satisfy the predicate in the slice.
+func IndicesN[Slice ~[]T, T any](xs Slice, n int, pred func(item T) bool) (indices []int) {
+	if xs == nil {
+		return nil
+	}
+
+	if n == 0 {
+		return Indices(xs, pred)
+	}
+
+	if n > 0 {
+		if n >= len(xs) {
+			return Indices(xs, pred)
+		}
+
+		indices = make([]int, 0, n)
+		for i := 0; i < len(xs) && len(indices) < n; i++ {
+			if pred(xs[i]) {
+				indices = append(indices, i)
+			}
+		}
+	} else {
+		n = -n
+		if n >= len(xs) {
+			return RIndices(xs, pred)
+		}
+
+		indices = make([]int, 0, n)
+		for i := len(xs) - 1; i >= 0 && len(indices) < n; i-- {
+			if pred(xs[i]) {
+				indices = append(indices, i)
+			}
+		}
+	}
+
+	return
+}
+
+// IIndicesN returns the first n indices of the elements that satisfy the predicate in the slice, with access to the index.
+func IIndicesN[Slice ~[]T, T any](xs Slice, n int, ipred func(int, T) bool) (indices []int) {
+	if xs == nil {
+		return nil
+	}
+
+	if n == 0 {
+		return IIndices(xs, ipred)
+	}
+
+	if n > 0 {
+		if n >= len(xs) {
+			return IIndices(xs, ipred)
+		}
+
+		indices = make([]int, 0, n)
+		for i := 0; i < len(xs) && len(indices) < n; i++ {
+			if ipred(i, xs[i]) {
+				indices = append(indices, i)
+			}
+		}
+	} else {
+		n = -n
+		if n >= len(xs) {
+			return IRIndices(xs, ipred)
+		}
+
+		indices = make([]int, 0, n)
+		for i := len(xs) - 1; i >= 0 && len(indices) < n; i-- {
+			if ipred(i, xs[i]) {
+				indices = append(indices, i)
+			}
+		}
+	}
+
+	return
+}
diff --git a/loslice/helpers.go b/loslice/helpers.go
new file mode 100644
index 00000000..8672f3ba
--- /dev/null
+++ b/loslice/helpers.go
@@ -0,0 +1,14 @@
+package loslice
+
+func allocateCapacity[Slice ~[]T, T any](mode AllocateMode, size int, precount func() int) (result Slice) {
+	switch mode {
+	default:
+		return nil // do nothing
+	case AllocateZero:
+		return make(Slice, 0)
+	case AllocateAll:
+		return make(Slice, 0, size)
+	case AllocatePrecount:
+		return make(Slice, 0, precount())
+	}
+}
diff --git a/loslice/internal/generate/nested/generate_nested.go b/loslice/internal/generate/nested/generate_nested.go
new file mode 100644
index 00000000..29968ac9
--- /dev/null
+++ b/loslice/internal/generate/nested/generate_nested.go
@@ -0,0 +1,86 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/nested/generate_nested.go"
+	filename           = "nested.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed nested.gotmpl
+	nestedRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+		"sub": func(x, y int) int { return x - y },
+	}
+	nestedTmpl := template.Must(template.New("nested").Funcs(funcMap).Parse(nestedRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_nested.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+	buf.WriteString(`
+func Get[Slice ~[]T, T any](s Slice, i int) (v T, ok bool) {
+	if i < 0 {
+		i += len(s)
+	}
+
+	if i < 0 || i >= len(s) {
+		return
+	}
+
+	return s[i], true
+}
+`)
+
+	for n := 2; n <= argumentsLimit; n++ {
+		err := nestedTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/loslice/internal/generate/nested/nested.gotmpl b/loslice/internal/generate/nested/nested.gotmpl
new file mode 100644
index 00000000..98a7e293
--- /dev/null
+++ b/loslice/internal/generate/nested/nested.gotmpl
@@ -0,0 +1,23 @@
+{{- define "decls-types" -}}{{ $N := .N }}
+	{{- range $i := .N }}
+		{{- if ne $i 0 }}, {{ end -}}
+		S{{ add $i 1 }} ~[]
+		{{- if eq $N (add $i 1) }}T{{ else }}S{{ add $i 2 }}{{ end -}}
+	{{- end }}
+{{- end }}
+{{- define "decls-args" -}}
+s1 S1{{ range $i := .N }}, i{{ add $i 1 }}{{ end }} int
+{{- end }}
+func Nested{{ .N }}[{{ template "decls-types" . }}, T any](
+	{{ template "decls-args" . }},
+) (v T, ok bool) {
+
+	{{ range $i := (sub .N 1) -}}
+	s{{ add $i 2 }}, ok := Get(s{{ add $i 1 }}, i{{ add $i 1 }})
+	if !ok {
+		return
+	}
+
+	{{ end -}}
+	return Get(s{{ .N }}, i{{ .N }})
+}
diff --git a/loslice/logic.go b/loslice/logic.go
new file mode 100644
index 00000000..116abfea
--- /dev/null
+++ b/loslice/logic.go
@@ -0,0 +1,64 @@
+package loslice
+
+import (
+	"github.com/samber/lo/lotup"
+	"slices"
+)
+
+// ContainsVal checks if there is at least one element in the slice that equals the given value.
+// Supports early exit, so it will stop checking as soon as it finds a match.
+func ContainsVal[Slice ~[]T, T comparable](xs Slice, val T) bool {
+	return slices.Contains(xs, val)
+}
+
+func WithoutVal[Slice ~[]T, T comparable](xs Slice, val T) bool {
+	return !ContainsVal(xs, val)
+}
+
+// Contains checks if there is at least one element in the slice that satisfies the predicate.
+func Contains[Slice ~[]T, T any](xs Slice, pred func(item T) bool) bool {
+	return lotup.Second(Index(xs, pred))
+}
+
+func Without[Slice ~[]T, T any](xs Slice, pred func(item T) bool) bool {
+	return !Contains(xs, pred)
+}
+
+// IContains checks if there is at least one element in the slice that satisfies the indexed predicate.
+func IContains[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) bool {
+	return lotup.Second(IIndex(xs, ipred))
+}
+
+func IWithout[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) bool {
+	return !IContains(xs, ipred)
+}
+
+func EveryVal[Slice ~[]T, T comparable](xs Slice, val T) bool {
+	for _, x := range xs {
+		if x != val {
+			return false
+		}
+	}
+
+	return true
+}
+
+func Every[Slice ~[]T, T any](xs Slice, pred func(item T) bool) bool {
+	for _, x := range xs {
+		if !pred(x) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func IEvery[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) bool {
+	for i, x := range xs {
+		if !ipred(i, x) {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/loslice/min_n_max.go b/loslice/min_n_max.go
new file mode 100644
index 00000000..31f1ce91
--- /dev/null
+++ b/loslice/min_n_max.go
@@ -0,0 +1,661 @@
+package loslice
+
+import "cmp"
+
+func MinVal[Slice ~[]T, T cmp.Ordered](xs Slice) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	res := xs[0]
+	for _, x := range xs[1:] {
+		if x < res {
+			res = x
+		}
+	}
+
+	return res
+}
+
+func ArgMinVal[Slice ~[]T, T cmp.Ordered](xs Slice) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	index := 0
+	for i, x := range xs[1:] {
+		if x < xs[index] {
+			index = i + 1
+		}
+	}
+
+	return index
+}
+
+func Min[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	t, r = xs[0], frank(xs[0])
+	for _, x := range xs[1:] {
+		if v := frank(x); v < r {
+			t, r = x, v
+		}
+	}
+
+	return
+}
+
+func ArgMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return 0, r
+	}
+
+	index = 0
+	r = frank(xs[0])
+	for i, x := range xs[1:] {
+		if v := frank(x); v < r {
+			index, r = i+1, v // +1 because we skipped the first element
+		}
+	}
+
+	return
+}
+
+func IMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	t, r = xs[0], irank(0, xs[0])
+	for i, x := range xs[1:] {
+		if v := irank(i+1, x); v < r { // +1 because we skipped the first element
+			t, r = x, v
+		}
+	}
+
+	return
+}
+
+func IArgMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return 0, r
+	}
+
+	index = 0
+	r = irank(0, xs[0])
+	for i, x := range xs[1:] {
+		if v := irank(i+1, x); v < r { // +1 because we skipped the first element
+			index, r = i+1, v
+		}
+	}
+
+	return
+}
+
+func RMinVal[Slice ~[]T, T cmp.Ordered](xs Slice) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	last := len(xs) - 1
+	res := xs[last]
+	for i := last - 1; i >= 0; i-- {
+		if x := xs[i]; x < res {
+			res = x
+		}
+	}
+
+	return res
+}
+
+func RArgMinVal[Slice ~[]T, T cmp.Ordered](xs Slice) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	last := len(xs) - 1
+	index := last
+	for i := last - 1; i >= 0; i-- {
+		if xs[i] < xs[index] {
+			index = i
+		}
+	}
+
+	return index
+}
+
+func RMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	t, r = xs[last], frank(xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := frank(xs[i]); v < r {
+			t, r = xs[i], v
+		}
+	}
+
+	return
+}
+
+func RArgMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	index, r = last, frank(xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := frank(xs[i]); v < r {
+			index, r = i, v
+		}
+	}
+
+	return
+}
+
+func IRMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(int, T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	t, r = xs[last], frank(last, xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := frank(i, xs[i]); v < r {
+			t, r = xs[i], v
+		}
+	}
+
+	return
+}
+
+func IRArgMin[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	index, r = last, irank(last, xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := irank(i, xs[i]); v < r {
+			index, r = i, v
+		}
+	}
+
+	return
+}
+
+func MaxVal[Slice ~[]T, T cmp.Ordered](xs Slice) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	res := xs[0]
+	for _, x := range xs[1:] {
+		if x > res {
+			res = x
+		}
+	}
+
+	return res
+}
+
+func ArgMaxVal[Slice ~[]T, T cmp.Ordered](xs Slice) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	index := 0
+	for i, x := range xs[1:] {
+		if x > xs[index] {
+			index = i + 1
+		}
+	}
+
+	return index
+}
+
+func Max[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	t, r = xs[0], frank(xs[0])
+	for _, x := range xs[1:] {
+		if v := frank(x); v > r {
+			t, r = x, v
+		}
+	}
+
+	return
+}
+
+func ArgMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return 0, r
+	}
+
+	index = 0
+	r = frank(xs[0])
+	for i, x := range xs[1:] {
+		if v := frank(x); v > r {
+			index, r = i+1, v
+		}
+	}
+
+	return
+}
+
+func IMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	t, r = xs[0], irank(0, xs[0])
+	for i, x := range xs[1:] {
+		if v := irank(i+1, x); v > r {
+			t, r = x, v
+		}
+	}
+
+	return
+}
+
+func IArgMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return 0, r
+	}
+
+	index = 0
+	r = irank(0, xs[0])
+	for i, x := range xs[1:] {
+		if v := irank(i+1, x); v > r {
+			index, r = i+1, v
+		}
+	}
+
+	return
+}
+
+func RMaxVal[Slice ~[]T, T cmp.Ordered](xs Slice) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	last := len(xs) - 1
+	res := xs[last]
+	for i := last - 1; i >= 0; i-- {
+		if x := xs[i]; x > res {
+			res = x
+		}
+	}
+
+	return res
+}
+
+func RArgMaxVal[Slice ~[]T, T cmp.Ordered](xs Slice) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	last := len(xs) - 1
+	index := last
+	for i := last - 1; i >= 0; i-- {
+		if xs[i] > xs[index] {
+			index = i
+		}
+	}
+
+	return index
+}
+
+func RMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	t, r = xs[last], frank(xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := frank(xs[i]); v > r {
+			t, r = xs[i], v
+		}
+	}
+
+	return
+}
+
+func RArgMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, frank func(T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	index, r = last, frank(xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := frank(xs[i]); v > r {
+			index, r = i, v
+		}
+	}
+
+	return
+}
+
+func IRMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (t T, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	t, r = xs[last], irank(last, xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := irank(i, xs[i]); v > r {
+			t, r = xs[i], v
+		}
+	}
+
+	return
+}
+
+func IRArgMax[Slice ~[]T, T any, R cmp.Ordered](xs Slice, irank func(int, T) R) (index int, r R) {
+	if len(xs) == 0 {
+		return
+	}
+
+	last := len(xs) - 1
+	index, r = last, irank(last, xs[last])
+	for i := last - 1; i >= 0; i-- {
+		if v := irank(i, xs[i]); v > r {
+			index, r = i, v
+		}
+	}
+
+	return
+}
+
+// MinCmp forward min using fcmp
+func MinCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	res := xs[0]
+	for _, x := range xs[1:] {
+		if fcmp(x, res) < 0 {
+			res = x
+		}
+	}
+
+	return res
+}
+
+// MaxCmp forward max using fcmp
+func MaxCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	res := xs[0]
+	for _, x := range xs[1:] {
+		if fcmp(x, res) > 0 {
+			res = x
+		}
+	}
+
+	return res
+}
+
+// RMinCmp reverse min using fcmp
+func RMinCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	last := len(xs) - 1
+	res := xs[last]
+	for i := last - 1; i >= 0; i-- {
+		if fcmp(xs[i], res) < 0 {
+			res = xs[i]
+		}
+	}
+
+	return res
+}
+
+// RMaxCmp reverse max using fcmp
+func RMaxCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	last := len(xs) - 1
+	res := xs[last]
+	for i := last - 1; i >= 0; i-- {
+		if fcmp(xs[i], res) > 0 {
+			res = xs[i]
+		}
+	}
+
+	return res
+}
+
+// IMinCmp forward min using index-aware icmp
+func IMinCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	index := 0
+	res := xs[0]
+	for i, x := range xs[1:] {
+		if icmp(i+1, index, x, res) < 0 {
+			index = i + 1 // +1 because we skipped the first element
+			res = x
+		}
+	}
+
+	return res
+}
+
+// IMaxCmp forward max using index-aware icmp
+func IMaxCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	index := 0
+	res := xs[0]
+	for i, x := range xs[1:] {
+		if icmp(i+1, index, x, res) > 0 {
+			index = i + 1 // +1 because we skipped the first element
+			res = x
+		}
+	}
+
+	return res
+}
+
+// IRMinCmp reverse min using index-aware icmp
+func IRMinCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	index := len(xs) - 1
+	res := xs[index]
+	for i := index - 1; i >= 0; i-- {
+		if icmp(i, index, xs[i], res) < 0 {
+			index = i
+			res = xs[i]
+		}
+	}
+
+	return res
+}
+
+// IRMaxCmp reverse max using index-aware icmp
+func IRMaxCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) T {
+	if len(xs) == 0 {
+		var zero T
+		return zero
+	}
+
+	index := len(xs) - 1
+	res := xs[index]
+	for i := index - 1; i >= 0; i-- {
+		if icmp(i, index, xs[i], res) > 0 {
+			index = i
+			res = xs[i]
+		}
+	}
+
+	return res
+}
+
+// ArgMinCmp forward min index using fcmp
+func ArgMinCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	index := 0
+	for i, x := range xs[1:] {
+		if fcmp(x, xs[index]) < 0 {
+			index = i + 1
+		}
+	}
+
+	return index
+}
+
+// ArgMaxCmp forward max index using fcmp
+func ArgMaxCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	index := 0
+	for i, x := range xs[1:] {
+		if fcmp(x, xs[index]) > 0 {
+			index = i + 1
+		}
+	}
+
+	return index
+}
+
+// RArgMinCmp reverse min index using fcmp
+func RArgMinCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	last := len(xs) - 1
+	index := last
+	for i := last - 1; i >= 0; i-- {
+		if fcmp(xs[i], xs[index]) < 0 {
+			index = i
+		}
+	}
+
+	return index
+}
+
+// RArgMaxCmp reverse max index using fcmp
+func RArgMaxCmp[Slice ~[]T, T any](xs Slice, fcmp func(a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	last := len(xs) - 1
+	index := last
+	for i := last - 1; i >= 0; i-- {
+		if fcmp(xs[i], xs[index]) > 0 {
+			index = i
+		}
+	}
+
+	return index
+}
+
+// IArgMinCmp forward min index using index-aware icmp
+func IArgMinCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	index := 0
+	for i, x := range xs[1:] {
+		if icmp(i+1, index, x, xs[index]) < 0 {
+			index = i + 1
+		}
+	}
+
+	return index
+}
+
+// IArgMaxCmp forward max index using index-aware icmp
+func IArgMaxCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	index := 0
+	for i, x := range xs[1:] {
+		if icmp(i+1, index, x, xs[index]) > 0 {
+			index = i + 1
+		}
+	}
+
+	return index
+}
+
+// IRArgMinCmp reverse min index using index-aware icmp
+func IRArgMinCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	last := len(xs) - 1
+	index := last
+	for i := last - 1; i >= 0; i-- {
+		if icmp(i, index, xs[i], xs[index]) < 0 {
+			index = i
+		}
+	}
+
+	return index
+}
+
+// IRArgMaxCmp reverse max index using index-aware icmp
+func IRArgMaxCmp[Slice ~[]T, T any](xs Slice, icmp func(i, j int, a, b T) int) int {
+	if len(xs) == 0 {
+		return 0
+	}
+
+	last := len(xs) - 1
+	index := last
+	for i := last - 1; i >= 0; i-- {
+		if icmp(i, index, xs[i], xs[index]) > 0 {
+			index = i
+		}
+	}
+
+	return index
+}
diff --git a/loslice/monad.go b/loslice/monad.go
new file mode 100644
index 00000000..616a18af
--- /dev/null
+++ b/loslice/monad.go
@@ -0,0 +1,122 @@
+package loslice
+
+func IsNil[Silce ~[]T, T any](xs Silce) bool {
+	return xs == nil
+}
+
+// IsEmpty checks if the slice is empty.
+func IsEmpty[Silce ~[]T, T any](xs Silce) bool {
+	return len(xs) == 0
+}
+
+func Len[Silce ~[]T, T any](xs Silce) int {
+	return len(xs)
+}
+
+func First[Silce ~[]T, T any](xs Silce) T {
+	return xs[0]
+}
+
+func Last[Silce ~[]T, T any](xs Silce) T {
+	return xs[len(xs)-1]
+}
+
+// Map manipulates a slice and transforms it to a slice not another type.
+func Map[R, T any, Silce ~[]T](xs Silce, fmap func(T) R) []R {
+	if xs == nil {
+		return nil
+	}
+
+	result := make([]R, len(xs))
+	for i, x := range xs {
+		result[i] = fmap(x)
+	}
+
+	return result
+}
+
+// IMap manipulates a slice and transforms it to a slice not another type, with access to the index.
+func IMap[R, T any, Silce ~[]T](xs Silce, imap func(int, T) R) []R {
+	if xs == nil {
+		return nil
+	}
+
+	result := make([]R, len(xs))
+	for i, x := range xs {
+		result[i] = imap(i, x)
+	}
+
+	return result
+}
+
+// FlatMap manipulates a slice and transforms and flattens it to a slice not another type.
+// The transform function can either return a slice or a `nil`, and in the `nil` case
+// no value is added to the final slice.
+func FlatMap[R, T any, Silce ~[]T](xs Silce, fmap func(T) []R) []R {
+	if xs == nil {
+		return nil
+	}
+
+	result := make([]R, 0, len(xs))
+	for _, x := range xs {
+		if rs := fmap(x); rs != nil {
+			result = append(result, rs...)
+		}
+	}
+
+	return result
+}
+
+// IFlatMap manipulates a slice and transforms and flattens it to a slice not another type, with access to the index.
+func IFlatMap[R, T any, Silce ~[]T](xs Silce, imap func(int, T) []R) []R {
+	if xs == nil {
+		return nil
+	}
+
+	result := make([]R, 0, len(xs))
+	for i, x := range xs {
+		if rs := imap(i, x); rs != nil {
+			result = append(result, rs...)
+		}
+	}
+
+	return result
+}
+
+// FilterMap returns a slice which obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result not the mapping operation and
+//   - whether the result element should be included or not.
+func FilterMap[R, T any, Slice ~[]T](xs Slice, fmap func(T) (R, bool)) []R {
+	if xs == nil {
+		return nil
+	}
+
+	result := make([]R, 0, len(xs))
+	for _, x := range xs {
+		if r, ok := fmap(x); ok {
+			result = append(result, r)
+		}
+	}
+
+	return result
+}
+
+// IFilterMap returns a slice which obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result not the mapping operation and
+//   - whether the result element should be included or not.
+func IFilterMap[R, T any, Slice ~[]T](xs Slice, imap func(int, T) (R, bool)) []R {
+	if xs == nil {
+		return nil
+	}
+
+	result := make([]R, 0, len(xs))
+	for i, x := range xs {
+		if r, ok := imap(i, x); ok {
+			result = append(result, r)
+		}
+	}
+
+	return result
+}
diff --git a/loslice/nested.go b/loslice/nested.go
new file mode 100644
index 00000000..9f8f75cb
--- /dev/null
+++ b/loslice/nested.go
@@ -0,0 +1,252 @@
+// Code generated by generate_nested.go; DO NOT EDIT.
+package loslice
+
+//go:generate go run internal/generate/nested/generate_nested.go
+
+func Get[Slice ~[]T, T any](s Slice, i int) (v T, ok bool) {
+	if i < 0 {
+		i += len(s)
+	}
+
+	if i < 0 || i >= len(s) {
+		return
+	}
+
+	return s[i], true
+}
+
+func Nested2[S1 ~[]S2, S2 ~[]T, T any](
+	s1 S1, i1, i2 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	return Get(s2, i2)
+}
+
+func Nested3[S1 ~[]S2, S2 ~[]S3, S3 ~[]T, T any](
+	s1 S1, i1, i2, i3 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	return Get(s3, i3)
+}
+
+func Nested4[S1 ~[]S2, S2 ~[]S3, S3 ~[]S4, S4 ~[]T, T any](
+	s1 S1, i1, i2, i3, i4 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	s4, ok := Get(s3, i3)
+	if !ok {
+		return
+	}
+
+	return Get(s4, i4)
+}
+
+func Nested5[S1 ~[]S2, S2 ~[]S3, S3 ~[]S4, S4 ~[]S5, S5 ~[]T, T any](
+	s1 S1, i1, i2, i3, i4, i5 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	s4, ok := Get(s3, i3)
+	if !ok {
+		return
+	}
+
+	s5, ok := Get(s4, i4)
+	if !ok {
+		return
+	}
+
+	return Get(s5, i5)
+}
+
+func Nested6[S1 ~[]S2, S2 ~[]S3, S3 ~[]S4, S4 ~[]S5, S5 ~[]S6, S6 ~[]T, T any](
+	s1 S1, i1, i2, i3, i4, i5, i6 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	s4, ok := Get(s3, i3)
+	if !ok {
+		return
+	}
+
+	s5, ok := Get(s4, i4)
+	if !ok {
+		return
+	}
+
+	s6, ok := Get(s5, i5)
+	if !ok {
+		return
+	}
+
+	return Get(s6, i6)
+}
+
+func Nested7[S1 ~[]S2, S2 ~[]S3, S3 ~[]S4, S4 ~[]S5, S5 ~[]S6, S6 ~[]S7, S7 ~[]T, T any](
+	s1 S1, i1, i2, i3, i4, i5, i6, i7 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	s4, ok := Get(s3, i3)
+	if !ok {
+		return
+	}
+
+	s5, ok := Get(s4, i4)
+	if !ok {
+		return
+	}
+
+	s6, ok := Get(s5, i5)
+	if !ok {
+		return
+	}
+
+	s7, ok := Get(s6, i6)
+	if !ok {
+		return
+	}
+
+	return Get(s7, i7)
+}
+
+func Nested8[S1 ~[]S2, S2 ~[]S3, S3 ~[]S4, S4 ~[]S5, S5 ~[]S6, S6 ~[]S7, S7 ~[]S8, S8 ~[]T, T any](
+	s1 S1, i1, i2, i3, i4, i5, i6, i7, i8 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	s4, ok := Get(s3, i3)
+	if !ok {
+		return
+	}
+
+	s5, ok := Get(s4, i4)
+	if !ok {
+		return
+	}
+
+	s6, ok := Get(s5, i5)
+	if !ok {
+		return
+	}
+
+	s7, ok := Get(s6, i6)
+	if !ok {
+		return
+	}
+
+	s8, ok := Get(s7, i7)
+	if !ok {
+		return
+	}
+
+	return Get(s8, i8)
+}
+
+func Nested9[S1 ~[]S2, S2 ~[]S3, S3 ~[]S4, S4 ~[]S5, S5 ~[]S6, S6 ~[]S7, S7 ~[]S8, S8 ~[]S9, S9 ~[]T, T any](
+	s1 S1, i1, i2, i3, i4, i5, i6, i7, i8, i9 int,
+) (v T, ok bool) {
+
+	s2, ok := Get(s1, i1)
+	if !ok {
+		return
+	}
+
+	s3, ok := Get(s2, i2)
+	if !ok {
+		return
+	}
+
+	s4, ok := Get(s3, i3)
+	if !ok {
+		return
+	}
+
+	s5, ok := Get(s4, i4)
+	if !ok {
+		return
+	}
+
+	s6, ok := Get(s5, i5)
+	if !ok {
+		return
+	}
+
+	s7, ok := Get(s6, i6)
+	if !ok {
+		return
+	}
+
+	s8, ok := Get(s7, i7)
+	if !ok {
+		return
+	}
+
+	s9, ok := Get(s8, i8)
+	if !ok {
+		return
+	}
+
+	return Get(s9, i9)
+}
diff --git a/loslice/split.go b/loslice/split.go
new file mode 100644
index 00000000..11a30805
--- /dev/null
+++ b/loslice/split.go
@@ -0,0 +1,55 @@
+package loslice
+
+func Split[Slice ~[]T, T any](xs Slice, pred func(T) bool) (taken, rest Slice) {
+	return splitImpl(xs, pred, nil, nil)
+}
+
+func SplitEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, pred func(T) bool) (taken, rest Slice) {
+	if xs == nil {
+		return nil, nil
+	}
+
+	taken = allocateCapacity[Slice](mode, len(xs), func() int { return Count(xs, pred) })
+	rest = allocateCapacity[Slice](mode, len(xs), func() int { return len(xs) - len(taken) })
+
+	return splitImpl(xs, pred, taken, rest)
+}
+
+func splitImpl[Slice ~[]T, T any](xs Slice, pred func(T) bool, taken, rest Slice) (Slice, Slice) {
+	for _, x := range xs {
+		if pred(x) {
+			taken = append(taken, x)
+		} else {
+			rest = append(rest, x)
+		}
+	}
+
+	return taken, rest
+}
+
+func ISplit[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (taken, rest Slice) {
+	return isplitImpl(xs, ipred, nil, nil)
+}
+
+func ISplitEx[Slice ~[]T, T any](mode AllocateMode, xs Slice, ipred func(int, T) bool) (taken, rest Slice) {
+	if xs == nil {
+		return nil, nil
+	}
+
+	taken = allocateCapacity[Slice](mode, len(xs), func() int { return ICount(xs, ipred) })
+	rest = allocateCapacity[Slice](mode, len(xs), func() int { return len(xs) - len(taken) })
+
+	return isplitImpl(xs, ipred, taken, rest)
+}
+
+func isplitImpl[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool, taken, rest Slice) (Slice, Slice) {
+	for i, x := range xs {
+		if ipred(i, x) {
+			taken = append(taken, x)
+		} else {
+			rest = append(rest, x)
+		}
+	}
+
+	return taken, rest
+}
diff --git a/loslice/table.go b/loslice/table.go
new file mode 100644
index 00000000..13a9d0e3
--- /dev/null
+++ b/loslice/table.go
@@ -0,0 +1,96 @@
+package loslice
+
+import "slices"
+
+// Flatten returns an array a single level deep.
+// Play: https://go.dev/play/p/rbp9ORaMpjw
+func Flatten[Slice ~[]T, T any](table ...Slice) Slice {
+	if len(table) == 0 || Every(table, IsNil) {
+		return nil
+	}
+
+	totalLen := MapSum(table, Len)
+	result := make(Slice, 0, totalLen)
+	for i := range table {
+		result = append(result, table[i]...)
+	}
+
+	return result
+}
+
+func Transpose[Slice ~[]T, T any](table ...Slice) []Slice {
+	n := len(table)
+	switch n {
+	case 0:
+		return nil
+	case 1:
+		xs := table[0]
+
+		if xs == nil {
+			return nil
+		}
+
+		result := make([]Slice, len(xs))
+		for i := range xs {
+			result[i] = Slice{xs[i]}
+		}
+
+		return result
+	}
+
+	sizes := Uniq(Map(table, Len))
+	if len(sizes) == 1 {
+		// all table have the same size
+		sz := sizes[0]
+
+		if sz == 0 && Every(table, IsNil) {
+			return nil
+		}
+
+		result := make([]Slice, sz)
+		for i := range result {
+			result[i] = make(Slice, n)
+			for j := range result[i] {
+				result[i][j] = table[j][i]
+			}
+		}
+
+		return result
+	}
+
+	slices.Sort(sizes)
+	j := 0
+	result := make([]Slice, sizes[len(sizes)-1])
+	for i := range result {
+		if i == sizes[j] {
+			j++
+
+			// drop short rows
+			last, size := 0, len(table)
+			for last < size && len(table[last]) > i {
+				last++
+			}
+
+			for k := last + 1; k < size; k++ {
+				if len(table[k]) > i {
+					table[last] = table[k]
+					last++
+				}
+			}
+
+			table = table[:last]
+		}
+
+		result[i] = make(Slice, len(table))
+		for k := range table {
+			result[i][k] = table[k][i]
+		}
+	}
+
+	return result
+}
+
+// Interleave round-robin alternating input slices and sequentially appending value at index into result
+func Interleave[Slice ~[]T, T any](table ...Slice) Slice {
+	return Flatten(Transpose(table...)...)
+}
diff --git a/loslice/types.go b/loslice/types.go
new file mode 100644
index 00000000..bd9fde74
--- /dev/null
+++ b/loslice/types.go
@@ -0,0 +1,9 @@
+package loslice
+
+type AllocateMode int
+
+const (
+	AllocateZero     AllocateMode = iota // grows while elements were added (few results, expensive precount)
+	AllocateAll                          // preallocate capacity for all elements (lots results, expensive precount)
+	AllocatePrecount                     // counts the number of elements and allocates exactly that amount of memory
+)
diff --git a/loslice/uniq.go b/loslice/uniq.go
new file mode 100644
index 00000000..df1f9fe5
--- /dev/null
+++ b/loslice/uniq.go
@@ -0,0 +1,21 @@
+package loslice
+
+// Uniq returns a duplicate-free version not an array, in which only the first occurrence not each element is kept.
+// The order not result values is determined by the order they occur in the array.
+func Uniq[Slice ~[]T, T comparable](xs Slice) Slice {
+	if xs == nil {
+		return nil
+	}
+
+	m := make(map[T]struct{}, len(xs))
+	for _, x := range xs {
+		m[x] = struct{}{}
+	}
+
+	res := make(Slice, 0, len(m))
+	for x := range m {
+		res = append(res, x)
+	}
+
+	return res
+}
diff --git a/loslice/uniq_test.go b/loslice/uniq_test.go
new file mode 100644
index 00000000..64240c37
--- /dev/null
+++ b/loslice/uniq_test.go
@@ -0,0 +1,28 @@
+package loslice_test
+
+import (
+	"github.com/samber/lo/loslice"
+	"github.com/stretchr/testify/assert"
+	"math/rand"
+	"testing"
+)
+
+const seed = 42
+
+func TestUniqInts(t *testing.T) {
+	t.Parallel()
+
+	rnd := rand.New(rand.NewSource(seed))
+
+	xs := make([]int, 100)
+	for i := range xs {
+		xs[i] = rnd.Intn(4) // Random integers between 0 and 9
+	}
+
+	uniq := loslice.Uniq(xs)
+	assert.Len(t, uniq, 4)
+
+	for _, x := range []int{0, 1, 2, 3} {
+		assert.Contains(t, uniq, x)
+	}
+}
diff --git a/lotup/access.go b/lotup/access.go
new file mode 100644
index 00000000..c5995982
--- /dev/null
+++ b/lotup/access.go
@@ -0,0 +1,68 @@
+// Code generated by generate_access.go; DO NOT EDIT.
+package lotup
+
+//go:generate go run internal/generate/access/generate_access.go
+
+func First[T any](first T, _ any) T {
+	return first
+}
+
+func Second[T any](_ any, second T) T {
+	return second
+}
+
+func First3[T any](first T, _, _ any) T {
+	return first
+}
+
+func Last3[T any](_, _ any, last T) T {
+	return last
+}
+
+func First4[T any](first T, _, _, _ any) T {
+	return first
+}
+
+func Last4[T any](_, _, _ any, last T) T {
+	return last
+}
+
+func First5[T any](first T, _, _, _, _ any) T {
+	return first
+}
+
+func Last5[T any](_, _, _, _ any, last T) T {
+	return last
+}
+
+func First6[T any](first T, _, _, _, _, _ any) T {
+	return first
+}
+
+func Last6[T any](_, _, _, _, _ any, last T) T {
+	return last
+}
+
+func First7[T any](first T, _, _, _, _, _, _ any) T {
+	return first
+}
+
+func Last7[T any](_, _, _, _, _, _ any, last T) T {
+	return last
+}
+
+func First8[T any](first T, _, _, _, _, _, _, _ any) T {
+	return first
+}
+
+func Last8[T any](_, _, _, _, _, _, _ any, last T) T {
+	return last
+}
+
+func First9[T any](first T, _, _, _, _, _, _, _, _ any) T {
+	return first
+}
+
+func Last9[T any](_, _, _, _, _, _, _, _ any, last T) T {
+	return last
+}
diff --git a/lotup/combinate.go b/lotup/combinate.go
new file mode 100644
index 00000000..e7bf9b5d
--- /dev/null
+++ b/lotup/combinate.go
@@ -0,0 +1,440 @@
+// Code generated by generate_combinate.go; DO NOT EDIT.
+package lotup
+
+//go:generate go run internal/generate/combinate/generate_combinate.go
+
+func Zip2[
+	T1, T2 any,
+	S1 ~[]T1, S2 ~[]T2,
+](s1 S1, s2 S2) []Tuple2[T1, T2] {
+	size := min(len(s1), len(s2))
+	res := make([]Tuple2[T1, T2], size)
+	for i := range size {
+		res[i] = Of2(s1[i], s2[i])
+	}
+
+	return res
+}
+
+func Unzip2[
+	T1, T2 any,
+	Slice ~[]Tuple2[T1, T2],
+](ts Slice) ([]T1, []T2) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	for i, t := range ts {
+		s1[i], s2[i] = t.Unpack()
+	}
+
+	return s1, s2
+}
+
+func Product2[
+	T1, T2 any,
+	S1 ~[]T1, S2 ~[]T2,
+](s1 S1, s2 S2) []Tuple2[T1, T2] {
+	size := len(s1) * len(s2)
+	res := make([]Tuple2[T1, T2], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			res = append(res, Of2(t1, t2))
+		}
+	}
+
+	return res
+}
+
+func Zip3[
+	T1, T2, T3 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3,
+](s1 S1, s2 S2, s3 S3) []Tuple3[T1, T2, T3] {
+	size := min(len(s1), len(s2), len(s3))
+	res := make([]Tuple3[T1, T2, T3], size)
+	for i := range size {
+		res[i] = Of3(s1[i], s2[i], s3[i])
+	}
+
+	return res
+}
+
+func Unzip3[
+	T1, T2, T3 any,
+	Slice ~[]Tuple3[T1, T2, T3],
+](ts Slice) ([]T1, []T2, []T3) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i] = t.Unpack()
+	}
+
+	return s1, s2, s3
+}
+
+func Product3[
+	T1, T2, T3 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3,
+](s1 S1, s2 S2, s3 S3) []Tuple3[T1, T2, T3] {
+	size := len(s1) * len(s2) * len(s3)
+	res := make([]Tuple3[T1, T2, T3], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				res = append(res, Of3(t1, t2, t3))
+			}
+		}
+	}
+
+	return res
+}
+
+func Zip4[
+	T1, T2, T3, T4 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4,
+](s1 S1, s2 S2, s3 S3, s4 S4) []Tuple4[T1, T2, T3, T4] {
+	size := min(len(s1), len(s2), len(s3), len(s4))
+	res := make([]Tuple4[T1, T2, T3, T4], size)
+	for i := range size {
+		res[i] = Of4(s1[i], s2[i], s3[i], s4[i])
+	}
+
+	return res
+}
+
+func Unzip4[
+	T1, T2, T3, T4 any,
+	Slice ~[]Tuple4[T1, T2, T3, T4],
+](ts Slice) ([]T1, []T2, []T3, []T4) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	s4 := make([]T4, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i], s4[i] = t.Unpack()
+	}
+
+	return s1, s2, s3, s4
+}
+
+func Product4[
+	T1, T2, T3, T4 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4,
+](s1 S1, s2 S2, s3 S3, s4 S4) []Tuple4[T1, T2, T3, T4] {
+	size := len(s1) * len(s2) * len(s3) * len(s4)
+	res := make([]Tuple4[T1, T2, T3, T4], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				for _, t4 := range s4 {
+					res = append(res, Of4(t1, t2, t3, t4))
+				}
+			}
+		}
+	}
+
+	return res
+}
+
+func Zip5[
+	T1, T2, T3, T4, T5 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5) []Tuple5[T1, T2, T3, T4, T5] {
+	size := min(len(s1), len(s2), len(s3), len(s4), len(s5))
+	res := make([]Tuple5[T1, T2, T3, T4, T5], size)
+	for i := range size {
+		res[i] = Of5(s1[i], s2[i], s3[i], s4[i], s5[i])
+	}
+
+	return res
+}
+
+func Unzip5[
+	T1, T2, T3, T4, T5 any,
+	Slice ~[]Tuple5[T1, T2, T3, T4, T5],
+](ts Slice) ([]T1, []T2, []T3, []T4, []T5) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	s4 := make([]T4, size)
+	s5 := make([]T5, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i], s4[i], s5[i] = t.Unpack()
+	}
+
+	return s1, s2, s3, s4, s5
+}
+
+func Product5[
+	T1, T2, T3, T4, T5 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5) []Tuple5[T1, T2, T3, T4, T5] {
+	size := len(s1) * len(s2) * len(s3) * len(s4) * len(s5)
+	res := make([]Tuple5[T1, T2, T3, T4, T5], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				for _, t4 := range s4 {
+					for _, t5 := range s5 {
+						res = append(res, Of5(t1, t2, t3, t4, t5))
+					}
+				}
+			}
+		}
+	}
+
+	return res
+}
+
+func Zip6[
+	T1, T2, T3, T4, T5, T6 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6) []Tuple6[T1, T2, T3, T4, T5, T6] {
+	size := min(len(s1), len(s2), len(s3), len(s4), len(s5), len(s6))
+	res := make([]Tuple6[T1, T2, T3, T4, T5, T6], size)
+	for i := range size {
+		res[i] = Of6(s1[i], s2[i], s3[i], s4[i], s5[i], s6[i])
+	}
+
+	return res
+}
+
+func Unzip6[
+	T1, T2, T3, T4, T5, T6 any,
+	Slice ~[]Tuple6[T1, T2, T3, T4, T5, T6],
+](ts Slice) ([]T1, []T2, []T3, []T4, []T5, []T6) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	s4 := make([]T4, size)
+	s5 := make([]T5, size)
+	s6 := make([]T6, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i], s4[i], s5[i], s6[i] = t.Unpack()
+	}
+
+	return s1, s2, s3, s4, s5, s6
+}
+
+func Product6[
+	T1, T2, T3, T4, T5, T6 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6) []Tuple6[T1, T2, T3, T4, T5, T6] {
+	size := len(s1) * len(s2) * len(s3) * len(s4) * len(s5) * len(s6)
+	res := make([]Tuple6[T1, T2, T3, T4, T5, T6], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				for _, t4 := range s4 {
+					for _, t5 := range s5 {
+						for _, t6 := range s6 {
+							res = append(res, Of6(t1, t2, t3, t4, t5, t6))
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return res
+}
+
+func Zip7[
+	T1, T2, T3, T4, T5, T6, T7 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6, S7 ~[]T7,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6, s7 S7) []Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+	size := min(len(s1), len(s2), len(s3), len(s4), len(s5), len(s6), len(s7))
+	res := make([]Tuple7[T1, T2, T3, T4, T5, T6, T7], size)
+	for i := range size {
+		res[i] = Of7(s1[i], s2[i], s3[i], s4[i], s5[i], s6[i], s7[i])
+	}
+
+	return res
+}
+
+func Unzip7[
+	T1, T2, T3, T4, T5, T6, T7 any,
+	Slice ~[]Tuple7[T1, T2, T3, T4, T5, T6, T7],
+](ts Slice) ([]T1, []T2, []T3, []T4, []T5, []T6, []T7) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	s4 := make([]T4, size)
+	s5 := make([]T5, size)
+	s6 := make([]T6, size)
+	s7 := make([]T7, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i], s4[i], s5[i], s6[i], s7[i] = t.Unpack()
+	}
+
+	return s1, s2, s3, s4, s5, s6, s7
+}
+
+func Product7[
+	T1, T2, T3, T4, T5, T6, T7 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6, S7 ~[]T7,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6, s7 S7) []Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+	size := len(s1) * len(s2) * len(s3) * len(s4) * len(s5) * len(s6) * len(s7)
+	res := make([]Tuple7[T1, T2, T3, T4, T5, T6, T7], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				for _, t4 := range s4 {
+					for _, t5 := range s5 {
+						for _, t6 := range s6 {
+							for _, t7 := range s7 {
+								res = append(res, Of7(t1, t2, t3, t4, t5, t6, t7))
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return res
+}
+
+func Zip8[
+	T1, T2, T3, T4, T5, T6, T7, T8 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6, S7 ~[]T7, S8 ~[]T8,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6, s7 S7, s8 S8) []Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+	size := min(len(s1), len(s2), len(s3), len(s4), len(s5), len(s6), len(s7), len(s8))
+	res := make([]Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], size)
+	for i := range size {
+		res[i] = Of8(s1[i], s2[i], s3[i], s4[i], s5[i], s6[i], s7[i], s8[i])
+	}
+
+	return res
+}
+
+func Unzip8[
+	T1, T2, T3, T4, T5, T6, T7, T8 any,
+	Slice ~[]Tuple8[T1, T2, T3, T4, T5, T6, T7, T8],
+](ts Slice) ([]T1, []T2, []T3, []T4, []T5, []T6, []T7, []T8) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	s4 := make([]T4, size)
+	s5 := make([]T5, size)
+	s6 := make([]T6, size)
+	s7 := make([]T7, size)
+	s8 := make([]T8, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i], s4[i], s5[i], s6[i], s7[i], s8[i] = t.Unpack()
+	}
+
+	return s1, s2, s3, s4, s5, s6, s7, s8
+}
+
+func Product8[
+	T1, T2, T3, T4, T5, T6, T7, T8 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6, S7 ~[]T7, S8 ~[]T8,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6, s7 S7, s8 S8) []Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+	size := len(s1) * len(s2) * len(s3) * len(s4) * len(s5) * len(s6) * len(s7) * len(s8)
+	res := make([]Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				for _, t4 := range s4 {
+					for _, t5 := range s5 {
+						for _, t6 := range s6 {
+							for _, t7 := range s7 {
+								for _, t8 := range s8 {
+									res = append(res, Of8(t1, t2, t3, t4, t5, t6, t7, t8))
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return res
+}
+
+func Zip9[
+	T1, T2, T3, T4, T5, T6, T7, T8, T9 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6, S7 ~[]T7, S8 ~[]T8, S9 ~[]T9,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6, s7 S7, s8 S8, s9 S9) []Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+	size := min(len(s1), len(s2), len(s3), len(s4), len(s5), len(s6), len(s7), len(s8), len(s9))
+	res := make([]Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], size)
+	for i := range size {
+		res[i] = Of9(s1[i], s2[i], s3[i], s4[i], s5[i], s6[i], s7[i], s8[i], s9[i])
+	}
+
+	return res
+}
+
+func Unzip9[
+	T1, T2, T3, T4, T5, T6, T7, T8, T9 any,
+	Slice ~[]Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9],
+](ts Slice) ([]T1, []T2, []T3, []T4, []T5, []T6, []T7, []T8, []T9) {
+	size := len(ts)
+
+	s1 := make([]T1, size)
+	s2 := make([]T2, size)
+	s3 := make([]T3, size)
+	s4 := make([]T4, size)
+	s5 := make([]T5, size)
+	s6 := make([]T6, size)
+	s7 := make([]T7, size)
+	s8 := make([]T8, size)
+	s9 := make([]T9, size)
+	for i, t := range ts {
+		s1[i], s2[i], s3[i], s4[i], s5[i], s6[i], s7[i], s8[i], s9[i] = t.Unpack()
+	}
+
+	return s1, s2, s3, s4, s5, s6, s7, s8, s9
+}
+
+func Product9[
+	T1, T2, T3, T4, T5, T6, T7, T8, T9 any,
+	S1 ~[]T1, S2 ~[]T2, S3 ~[]T3, S4 ~[]T4, S5 ~[]T5, S6 ~[]T6, S7 ~[]T7, S8 ~[]T8, S9 ~[]T9,
+](s1 S1, s2 S2, s3 S3, s4 S4, s5 S5, s6 S6, s7 S7, s8 S8, s9 S9) []Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+	size := len(s1) * len(s2) * len(s3) * len(s4) * len(s5) * len(s6) * len(s7) * len(s8) * len(s9)
+	res := make([]Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], 0, size)
+
+	for _, t1 := range s1 {
+		for _, t2 := range s2 {
+			for _, t3 := range s3 {
+				for _, t4 := range s4 {
+					for _, t5 := range s5 {
+						for _, t6 := range s6 {
+							for _, t7 := range s7 {
+								for _, t8 := range s8 {
+									for _, t9 := range s9 {
+										res = append(res, Of9(t1, t2, t3, t4, t5, t6, t7, t8, t9))
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return res
+}
diff --git a/lotup/internal/generate/access/access.gotmpl b/lotup/internal/generate/access/access.gotmpl
new file mode 100644
index 00000000..346e25c3
--- /dev/null
+++ b/lotup/internal/generate/access/access.gotmpl
@@ -0,0 +1,8 @@
+
+func First{{ .N }}[T any](first T{{range $i := (sub .N 1) }}, _{{ end }} any) T {
+	return first
+}
+
+func Last{{ .N }}[T any]({{range $i := (sub .N 1) }}{{ if ne $i 0 }}, {{ end }}_{{ end }} any, last T) T {
+	return last
+}
diff --git a/lotup/internal/generate/access/generate_access.go b/lotup/internal/generate/access/generate_access.go
new file mode 100644
index 00000000..b7f9cfb5
--- /dev/null
+++ b/lotup/internal/generate/access/generate_access.go
@@ -0,0 +1,82 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/access/generate_access.go"
+	filename           = "access.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed access.gotmpl
+	ofRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+		"sub": func(x, y int) int { return x - y },
+	}
+	ofTmpl := template.Must(template.New("of").Funcs(funcMap).Parse(ofRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_access.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+	buf.WriteString(`
+func First[T any](first T, _ any) T {
+	return first
+}
+
+func Second[T any](_ any, second T) T {
+	return second
+}
+`)
+
+	for n := 3; n <= argumentsLimit; n++ {
+		err := ofTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lotup/internal/generate/combinate/generate_combinate.go b/lotup/internal/generate/combinate/generate_combinate.go
new file mode 100644
index 00000000..9bed2305
--- /dev/null
+++ b/lotup/internal/generate/combinate/generate_combinate.go
@@ -0,0 +1,91 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/combinate/generate_combinate.go"
+	filename           = "combinate.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed templates/zip.gotmpl
+	zipRaw string
+
+	//go:embed templates/unzip.gotmpl
+	unzipRaw string
+
+	//go:embed templates/product.gotmpl
+	productRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+		"sub": func(x, y int) int { return x - y },
+	}
+	zipTmpl := template.Must(template.New("zip").Funcs(funcMap).Parse(zipRaw))
+	unzipTmpl := template.Must(template.New("unzip").Funcs(funcMap).Parse(unzipRaw))
+	productTmpl := template.Must(template.New("product").Funcs(funcMap).Parse(productRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_combinate.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+
+	for n := 2; n <= argumentsLimit; n++ {
+		err := zipTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+
+		err = unzipTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+
+		err = productTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lotup/internal/generate/combinate/templates/product.gotmpl b/lotup/internal/generate/combinate/templates/product.gotmpl
new file mode 100644
index 00000000..71cdf35b
--- /dev/null
+++ b/lotup/internal/generate/combinate/templates/product.gotmpl
@@ -0,0 +1,28 @@
+{{- define "decls-types" -}}
+[
+	{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }} any,
+	{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}S{{ add $i 1 }} ~[]T{{ add $i 1 }}{{ end }},
+]
+{{- end }}
+{{- define "decls-args" -}}
+({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}s{{ add $i 1 }} S{{ add $i 1 }}{{ end }})
+{{- end }}
+{{- define "decls-tuple" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}]
+{{- end }}
+{{- $N := .N }}
+func Product{{ .N }}{{ template "decls-types" . }}{{ template "decls-args" . }} []{{ template "decls-tuple" . }} {
+	size := {{ range $i := .N }}{{ if ne $i 0 }} * {{ end }}len(s{{ add $i 1 }}){{ end }}
+	res := make([]{{ template "decls-tuple" . }}, 0, size)
+{{ range $i := .N }}
+	{{ range $i }}	{{ end }}for _, t{{ add $i 1 }} := range s{{ add $i 1 }} {
+{{- end }}
+	{{ range .N }}	{{ end }}res = append(res, Of{{ .N }}(
+		{{- range $i := .N }}{{ if ne $i 0 }}, {{ end }}t{{ add $i 1 }}{{ end -}}
+		))
+{{- range $i := .N }}
+{{ range (sub $N $i) }}	{{ end }}}
+{{- end }}
+
+	return res
+}
diff --git a/lotup/internal/generate/combinate/templates/unzip.gotmpl b/lotup/internal/generate/combinate/templates/unzip.gotmpl
new file mode 100644
index 00000000..964eb41b
--- /dev/null
+++ b/lotup/internal/generate/combinate/templates/unzip.gotmpl
@@ -0,0 +1,24 @@
+{{- define "decls-tuple" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}]
+{{- end }}
+{{- define "decls-types" -}}
+[
+	{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }} any,
+	Slice ~[]{{ template "decls-tuple" . }},
+]
+{{- end }}
+{{- define "decls-results" -}}
+({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}[]T{{ add $i 1 }}{{ end }})
+{{- end }}
+func Unzip{{ .N }}{{ template "decls-types" . }}(ts Slice) {{ template "decls-results" . }} {
+	size := len(ts)
+{{ range $i := .N }}
+	s{{ add $i 1 }} := make([]T{{ add $i 1 }}, size)
+{{- end }}
+	for i, t := range ts {
+		{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}s{{ add $i 1 }}[i]
+		{{- end }} = t.Unpack()
+	}
+
+	return {{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}s{{ add $i 1 }}{{ end }}
+}
diff --git a/lotup/internal/generate/combinate/templates/zip.gotmpl b/lotup/internal/generate/combinate/templates/zip.gotmpl
new file mode 100644
index 00000000..9759ebfd
--- /dev/null
+++ b/lotup/internal/generate/combinate/templates/zip.gotmpl
@@ -0,0 +1,25 @@
+{{- define "decls-types" -}}
+[
+	{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }} any,
+	{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}S{{ add $i 1 }} ~[]T{{ add $i 1 }}{{ end }},
+]
+{{- end }}
+{{- define "decls-args" -}}
+({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}s{{ add $i 1 }} S{{ add $i 1 }}{{ end }})
+{{- end }}
+{{- define "decls-tuple" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}]
+{{- end }}
+func Zip{{ .N }}{{ template "decls-types" . }}{{ template "decls-args" . }} []{{ template "decls-tuple" . }} {
+	size := min(
+		{{- range $i := .N }}{{ if ne $i 0 }}, {{ end }}len(s{{ add $i 1 }}){{ end -}}
+	)
+	res := make([]{{ template "decls-tuple" . }}, size)
+	for i := range size {
+		res[i] = Of{{ .N }}(
+			{{- range $i := .N }}{{ if ne $i 0 }}, {{ end }}s{{ add $i 1 }}[i]{{ end -}}
+		)
+	}
+
+	return res
+}
diff --git a/lotup/internal/generate/of/generate_of.go b/lotup/internal/generate/of/generate_of.go
new file mode 100644
index 00000000..a935d68f
--- /dev/null
+++ b/lotup/internal/generate/of/generate_of.go
@@ -0,0 +1,72 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/of/generate_of.go"
+	filename           = "of.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed of.gotmpl
+	ofRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+	}
+	ofTmpl := template.Must(template.New("of").Funcs(funcMap).Parse(ofRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_of.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+
+	for n := 2; n <= argumentsLimit; n++ {
+		err := ofTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lotup/internal/generate/of/of.gotmpl b/lotup/internal/generate/of/of.gotmpl
new file mode 100644
index 00000000..e376feb0
--- /dev/null
+++ b/lotup/internal/generate/of/of.gotmpl
@@ -0,0 +1,14 @@
+{{- define "decls-types" -}}
+[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }} any]
+{{- end }}
+{{- define "decls-args" -}}
+({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}v{{ add $i 1 }} T{{ add $i 1 }}{{ end }})
+{{- end }}
+{{- define "decls-tuple" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}]
+{{- end }}
+func Of{{ .N }}{{ template "decls-types" . }}{{ template "decls-args" . }} {{ template "decls-tuple" . }} {
+	return {{ template "decls-tuple" . }}{
+		{{ range $i := .N }}{{if ne $i 0}} {{end}}V{{ add $i 1 }}: v{{ add $i 1 }},{{ end }}
+	}
+}
diff --git a/lotup/internal/generate/tuples/generate_tuples.go b/lotup/internal/generate/tuples/generate_tuples.go
new file mode 100644
index 00000000..b7bbee87
--- /dev/null
+++ b/lotup/internal/generate/tuples/generate_tuples.go
@@ -0,0 +1,90 @@
+//go:build generate_monad
+
+package main
+
+import (
+	_ "embed"
+
+	"bytes"
+	"fmt"
+	"io/fs"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"text/template"
+)
+
+const (
+	monadGeneratorPath = "internal/generate/tuples/generate_tuples.go"
+	filename           = "tuples.go"
+
+	ownerWritePermission = 0o644
+
+	argumentsLimit = 9
+)
+
+var (
+	//go:embed templates/class.gotmpl
+	classRaw string
+
+	//go:embed templates/unpack.gotmpl
+	unpackRaw string
+
+	//go:embed templates/last.gotmpl
+	lastRaw string
+)
+
+type Variant struct {
+	N int
+}
+
+func main() {
+	funcMap := template.FuncMap{
+		"add": func(x, y int) int { return x + y },
+	}
+	classTmpl := template.Must(template.New("class").Funcs(funcMap).Parse(classRaw))
+	unpackTmpl := template.Must(template.New("unpack").Funcs(funcMap).Parse(unpackRaw))
+	lastTmpl := template.Must(template.New("last").Funcs(funcMap).Parse(lastRaw))
+
+	pkg := detectPackageName()
+
+	var buf bytes.Buffer
+
+	buf.WriteString("// Code generated by generate_tuples.go; DO NOT EDIT.\n")
+	buf.WriteString(fmt.Sprintf("package %s\n\n", pkg))
+	buf.WriteString(fmt.Sprintf("//go:generate go run %s\n", monadGeneratorPath))
+
+	for n := 2; n <= argumentsLimit; n++ {
+		err := classTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+
+		err = unpackTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+
+		err = lastTmpl.Execute(&buf, Variant{N: n})
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	err := os.WriteFile(filename, buf.Bytes(), fs.FileMode(ownerWritePermission))
+	if err != nil {
+		panic(err)
+	}
+
+	slog.Info("done")
+}
+
+func detectPackageName() string {
+	out, err := exec.Command("go", "list", "-f", "{{.Name}}").Output()
+	if err != nil {
+		panic(err)
+	}
+
+	return strings.TrimSpace(string(out))
+}
diff --git a/lotup/internal/generate/tuples/templates/class.gotmpl b/lotup/internal/generate/tuples/templates/class.gotmpl
new file mode 100644
index 00000000..7e5145ea
--- /dev/null
+++ b/lotup/internal/generate/tuples/templates/class.gotmpl
@@ -0,0 +1,8 @@
+{{- define "tuple-type" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }} any]
+{{- end }}
+type {{ template "tuple-type" . }} struct {
+{{- range $i := .N }}
+	V{{ add $i 1 }} T{{ add $i 1 }}
+{{- end }}
+}
diff --git a/lotup/internal/generate/tuples/templates/last.gotmpl b/lotup/internal/generate/tuples/templates/last.gotmpl
new file mode 100644
index 00000000..c7b52ed7
--- /dev/null
+++ b/lotup/internal/generate/tuples/templates/last.gotmpl
@@ -0,0 +1,6 @@
+{{- define "tuple-type" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}]
+{{- end }}
+func (t {{ template "tuple-type" . }}) Last() T{{ .N }} {
+	return t.V{{ .N }}
+}
diff --git a/lotup/internal/generate/tuples/templates/unpack.gotmpl b/lotup/internal/generate/tuples/templates/unpack.gotmpl
new file mode 100644
index 00000000..5bc8f6c9
--- /dev/null
+++ b/lotup/internal/generate/tuples/templates/unpack.gotmpl
@@ -0,0 +1,9 @@
+{{- define "tuple-type" -}}
+Tuple{{ .N }}[{{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }}]
+{{- end }}
+{{- define "decls-types" -}}
+({{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}T{{ add $i 1 }}{{ end }})
+{{- end }}
+func (t {{ template "tuple-type" . }}) Unpack() {{ template "decls-types" . }} {
+	return {{ range $i := .N }}{{ if ne $i 0 }}, {{ end }}t.V{{ add $i 1 }}{{ end }}
+}
diff --git a/lotup/of.go b/lotup/of.go
new file mode 100644
index 00000000..8d247440
--- /dev/null
+++ b/lotup/of.go
@@ -0,0 +1,52 @@
+// Code generated by generate_of.go; DO NOT EDIT.
+package lotup
+
+//go:generate go run internal/generate/of/generate_of.go
+
+func Of2[T1, T2 any](v1 T1, v2 T2) Tuple2[T1, T2] {
+	return Tuple2[T1, T2]{
+		V1: v1, V2: v2,
+	}
+}
+
+func Of3[T1, T2, T3 any](v1 T1, v2 T2, v3 T3) Tuple3[T1, T2, T3] {
+	return Tuple3[T1, T2, T3]{
+		V1: v1, V2: v2, V3: v3,
+	}
+}
+
+func Of4[T1, T2, T3, T4 any](v1 T1, v2 T2, v3 T3, v4 T4) Tuple4[T1, T2, T3, T4] {
+	return Tuple4[T1, T2, T3, T4]{
+		V1: v1, V2: v2, V3: v3, V4: v4,
+	}
+}
+
+func Of5[T1, T2, T3, T4, T5 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) Tuple5[T1, T2, T3, T4, T5] {
+	return Tuple5[T1, T2, T3, T4, T5]{
+		V1: v1, V2: v2, V3: v3, V4: v4, V5: v5,
+	}
+}
+
+func Of6[T1, T2, T3, T4, T5, T6 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) Tuple6[T1, T2, T3, T4, T5, T6] {
+	return Tuple6[T1, T2, T3, T4, T5, T6]{
+		V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6,
+	}
+}
+
+func Of7[T1, T2, T3, T4, T5, T6, T7 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+	return Tuple7[T1, T2, T3, T4, T5, T6, T7]{
+		V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7,
+	}
+}
+
+func Of8[T1, T2, T3, T4, T5, T6, T7, T8 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+	return Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{
+		V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8,
+	}
+}
+
+func Of9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+	return Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{
+		V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8, V9: v9,
+	}
+}
diff --git a/lotup/tuples.go b/lotup/tuples.go
new file mode 100644
index 00000000..d62d7f65
--- /dev/null
+++ b/lotup/tuples.go
@@ -0,0 +1,136 @@
+// Code generated by generate_tuples.go; DO NOT EDIT.
+package lotup
+
+//go:generate go run internal/generate/tuples/generate_tuples.go
+
+type Tuple2[T1, T2 any] struct {
+	V1 T1
+	V2 T2
+}
+
+func (t Tuple2[T1, T2]) Unpack() (T1, T2) {
+	return t.V1, t.V2
+}
+
+func (t Tuple2[T1, T2]) Last() T2 {
+	return t.V2
+}
+
+type Tuple3[T1, T2, T3 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+}
+
+func (t Tuple3[T1, T2, T3]) Unpack() (T1, T2, T3) {
+	return t.V1, t.V2, t.V3
+}
+
+func (t Tuple3[T1, T2, T3]) Last() T3 {
+	return t.V3
+}
+
+type Tuple4[T1, T2, T3, T4 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+}
+
+func (t Tuple4[T1, T2, T3, T4]) Unpack() (T1, T2, T3, T4) {
+	return t.V1, t.V2, t.V3, t.V4
+}
+
+func (t Tuple4[T1, T2, T3, T4]) Last() T4 {
+	return t.V4
+}
+
+type Tuple5[T1, T2, T3, T4, T5 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+}
+
+func (t Tuple5[T1, T2, T3, T4, T5]) Unpack() (T1, T2, T3, T4, T5) {
+	return t.V1, t.V2, t.V3, t.V4, t.V5
+}
+
+func (t Tuple5[T1, T2, T3, T4, T5]) Last() T5 {
+	return t.V5
+}
+
+type Tuple6[T1, T2, T3, T4, T5, T6 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+}
+
+func (t Tuple6[T1, T2, T3, T4, T5, T6]) Unpack() (T1, T2, T3, T4, T5, T6) {
+	return t.V1, t.V2, t.V3, t.V4, t.V5, t.V6
+}
+
+func (t Tuple6[T1, T2, T3, T4, T5, T6]) Last() T6 {
+	return t.V6
+}
+
+type Tuple7[T1, T2, T3, T4, T5, T6, T7 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+	V7 T7
+}
+
+func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) Unpack() (T1, T2, T3, T4, T5, T6, T7) {
+	return t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7
+}
+
+func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) Last() T7 {
+	return t.V7
+}
+
+type Tuple8[T1, T2, T3, T4, T5, T6, T7, T8 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+	V7 T7
+	V8 T8
+}
+
+func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Unpack() (T1, T2, T3, T4, T5, T6, T7, T8) {
+	return t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7, t.V8
+}
+
+func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Last() T8 {
+	return t.V8
+}
+
+type Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+	V7 T7
+	V8 T8
+	V9 T9
+}
+
+func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Unpack() (T1, T2, T3, T4, T5, T6, T7, T8, T9) {
+	return t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7, t.V8, t.V9
+}
+
+func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Last() T9 {
+	return t.V9
+}
diff --git a/lotype/cast.go b/lotype/cast.go
new file mode 100644
index 00000000..59a36cdb
--- /dev/null
+++ b/lotype/cast.go
@@ -0,0 +1,15 @@
+package lotype
+
+type Number interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
+		~float32 | ~float64
+}
+
+func CastNum[R, T Number](x T) R {
+	return R(x)
+}
+
+func CastStr[R, T ~string](x T) R {
+	return R(x)
+}
diff --git a/mutmap/filter.go b/mutmap/filter.go
new file mode 100644
index 00000000..7a8e3dc2
--- /dev/null
+++ b/mutmap/filter.go
@@ -0,0 +1,37 @@
+package mutmap
+
+// In-place reject: removes all entries with value == val.
+func RejectVal[Map ~map[K]V, K, V comparable](m Map, val V) {
+	for k, v := range m {
+		if v == val {
+			delete(m, k)
+		}
+	}
+}
+
+// In-place filter: keeps only keys for which pred returns true.
+func FilterKeys[Map ~map[K]V, K comparable, V any](m Map, pred func(K) bool) {
+	for k := range m {
+		if !pred(k) {
+			delete(m, k)
+		}
+	}
+}
+
+// In-place filter: keeps only values for which pred returns true.
+func FilterValues[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool) {
+	for k, v := range m {
+		if !pred(v) {
+			delete(m, k)
+		}
+	}
+}
+
+// In-place filter: keeps only pairs for which pred returns true.
+func FilterPairs[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool) {
+	for k, v := range m {
+		if !pred(k, v) {
+			delete(m, k)
+		}
+	}
+}
diff --git a/mutmap/monad.go b/mutmap/monad.go
new file mode 100644
index 00000000..98ae4b52
--- /dev/null
+++ b/mutmap/monad.go
@@ -0,0 +1,68 @@
+package mutmap
+
+import (
+	"github.com/samber/lo/lomap"
+	"maps"
+)
+
+func MapValues[Map ~map[K]V, K comparable, V any](m Map, fmap func(V) V) {
+	for k, v := range m {
+		m[k] = fmap(v)
+	}
+}
+
+func MapKeys[Map ~map[K]V, K comparable, V any](m Map, fmap func(K) V) {
+	for k := range m {
+		m[k] = fmap(k)
+	}
+}
+
+func MapPairs[Map ~map[K]V, K comparable, V any](m Map, fmap func(K, V) V) {
+	for k, v := range m {
+		m[k] = fmap(k, v)
+	}
+}
+
+func FullMap[Map ~map[K]V, K comparable, V any](m Map, fmap func(K, V) (K, V)) {
+	res := lomap.FullMap(m, fmap)
+
+	Clear(m)
+	maps.Copy(m, res)
+}
+
+func FilterMapValues[Map ~map[K]V, K comparable, V any](m Map, fmap func(V) (V, bool)) {
+	for k, v := range m {
+		if nv, ok := fmap(v); ok {
+			m[k] = nv
+		} else {
+			delete(m, k)
+		}
+	}
+}
+
+func FilterMapKeys[Map ~map[K]V, K comparable, V any](m Map, fmap func(K) (V, bool)) {
+	for k := range m {
+		if nv, ok := fmap(k); ok {
+			m[k] = nv
+		} else {
+			delete(m, k)
+		}
+	}
+}
+
+func FilterMapPairs[Map ~map[K]V, K comparable, V any](m Map, fmap func(K, V) (V, bool)) {
+	for k, v := range m {
+		if nv, ok := fmap(k, v); ok {
+			m[k] = nv
+		} else {
+			delete(m, k)
+		}
+	}
+}
+
+func FilterFullMap[Map ~map[K]V, K comparable, V any](m Map, fmap func(K, V) (K, V, bool)) {
+	res := lomap.FilterFullMap(m, fmap)
+
+	Clear(m)
+	maps.Copy(m, res)
+}
diff --git a/mutmap/mutmap.go b/mutmap/mutmap.go
new file mode 100644
index 00000000..699ad7e3
--- /dev/null
+++ b/mutmap/mutmap.go
@@ -0,0 +1,38 @@
+package mutmap
+
+func ForceNil[Map ~map[K]V, K comparable, V any](m Map) Map {
+	if len(m) == 0 {
+		return nil
+	}
+
+	return m
+}
+
+func ForceEmpty[Map ~map[K]V, K comparable, V any](m Map) Map {
+	if m == nil {
+		return make(Map)
+	}
+
+	return m
+}
+
+func ToPointers[Map ~map[K]V, K comparable, V any](m Map) (res map[K]*V) {
+	pointers := make([]V, len(m))
+	res = make(map[K]*V, len(m))
+
+	var k K
+	i := 0
+
+	for k, pointers[i] = range m {
+		res[k] = &pointers[i]
+		i++
+	}
+
+	return res
+}
+
+func Clear[Map ~map[K]V, K comparable, V any](m Map) {
+	for k := range m {
+		delete(m, k)
+	}
+}
diff --git a/mutmap/operations.go b/mutmap/operations.go
new file mode 100644
index 00000000..b06702f6
--- /dev/null
+++ b/mutmap/operations.go
@@ -0,0 +1,98 @@
+package mutmap
+
+import (
+	"github.com/samber/lo/lomap"
+	"github.com/samber/lo/loslice"
+)
+
+// Update replaces existing keys in the map with values from another map.
+// First map in the list has the highest priority.
+// No new keys are added, only existing keys are updated.
+func Update[Map ~map[K]V, K comparable, V any](self, other Map, more ...Map) {
+	for k := range self {
+		if v, exists := other[k]; exists {
+			self[k] = v
+			continue
+		}
+	}
+
+	if len(more) == 0 || loslice.Every(more, lomap.IsEmpty) {
+		return // If no additional maps are provided, or they have no elements, we are done
+	}
+
+	for k := range self {
+		for _, m := range more {
+			if v, exists := m[k]; exists {
+				self[k] = v
+				break // Stop at the first match
+			}
+		}
+	}
+}
+
+// Add adds new keys and values from another map to the current map.
+// First map in the list has the highest priority.
+// No existing keys are modified, only new keys are added.
+func Add[Map ~map[K]V, K comparable, V any](self, other Map, more ...Map) {
+	for k, v := range other {
+		if _, exists := self[k]; !exists {
+			self[k] = v
+		}
+	}
+
+	for _, m := range more {
+		for k, v := range m {
+			if _, exists := self[k]; !exists {
+				self[k] = v
+			}
+		}
+	}
+}
+
+// Remove deletes keys from the current map that are present in another map.
+func Remove[Map ~map[K]V, K comparable, V any](self, other Map, more ...Map) {
+	for k := range other {
+		delete(self, k)
+	}
+
+	if len(more) == 0 || loslice.Every(more, lomap.IsEmpty) {
+		return // If no additional maps are provided, or they have no elements, we are done
+	}
+
+	for k := range self {
+		for _, m := range more {
+			if _, exists := m[k]; exists {
+				delete(self, k)
+				break // Stop at the first match
+			}
+		}
+	}
+}
+
+// KeepCommon retains only the keys that are present in both maps.
+// Values left unchanged.
+func KeepCommon[Map ~map[K]V, K comparable, V any](self, other Map, more ...Map) {
+	if len(other) == 0 || loslice.Contains(more, lomap.IsEmpty) {
+		Clear(self) // Clear the map if the other map is empty or if any of the additional maps are empty
+		return
+	}
+
+	for k := range self {
+		if _, exists := other[k]; !exists {
+			delete(self, k)
+		}
+	}
+
+	if len(more) == 0 {
+		return // If no additional maps are provided, we are done
+	}
+
+	for k := range self {
+		for _, m := range more {
+			if _, exists := m[k]; !exists {
+				delete(self, k)
+				break // Stop at the first match
+			}
+		}
+	}
+}
diff --git a/mutmap/replace.go b/mutmap/replace.go
new file mode 100644
index 00000000..ed40ed76
--- /dev/null
+++ b/mutmap/replace.go
@@ -0,0 +1,43 @@
+package mutmap
+
+import (
+	"github.com/samber/lo/lomap"
+	"maps"
+)
+
+func ReplaceVal[Map ~map[K]V, K, V comparable](m Map, oldVal, newVal V) {
+	for k, v := range m {
+		if v == oldVal {
+			m[k] = newVal
+		}
+	}
+}
+
+func Replace[Map ~map[K]V, K comparable, V any](m Map, pred func(V) bool, fmap func(V) V) {
+	for k, v := range m {
+		if pred(v) {
+			m[k] = fmap(v)
+		}
+	}
+}
+
+func KReplace[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool, fmap func(K, V) V) {
+	for k, v := range m {
+		if pred(k, v) {
+			m[k] = fmap(k, v)
+		}
+	}
+}
+
+func FullReplace[Map ~map[K]V, K comparable, V any](m Map, pred func(K, V) bool, fmap func(K, V) (K, V)) {
+	res := lomap.FullMap(m, func(k K, v V) (K, V) {
+		if pred(k, v) {
+			return fmap(k, v)
+		}
+
+		return k, v
+	})
+
+	Clear(m)
+	maps.Copy(m, res)
+}
diff --git a/mutslice/filter.go b/mutslice/filter.go
new file mode 100644
index 00000000..0a62085c
--- /dev/null
+++ b/mutslice/filter.go
@@ -0,0 +1,52 @@
+package mutslice
+
+// RejectVal remove all occurrences of a value from a slice or array.
+func RejectVal[Slice ~[]T, T comparable](xs Slice, val T) Slice {
+	last, size := 0, len(xs)
+	for last < size && xs[last] != val {
+		last++
+	}
+
+	for i := last + 1; i < size; i++ {
+		if xs[i] != val {
+			xs[last] = xs[i]
+			last++
+		}
+	}
+
+	return xs[:last]
+}
+
+// Filter iterates over elements not collection, reordering elements that match the predicate to the front not the slice.
+func Filter[Slice ~[]T, T any](xs Slice, pred func(item T) bool) Slice {
+	last, size := 0, len(xs)
+	for last < size && pred(xs[last]) {
+		last++
+	}
+
+	for i := last + 1; i < size; i++ {
+		if pred(xs[i]) {
+			xs[last] = xs[i]
+			last++
+		}
+	}
+
+	return xs[:last]
+}
+
+// IFilter iterates over elements not collection, reordering elements that match the predicate to the front not the slice.
+func IFilter[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) Slice {
+	last, size := 0, len(xs)
+	for last < size && ipred(last, xs[last]) {
+		last++
+	}
+
+	for i := last + 1; i < size; i++ {
+		if ipred(i, xs[i]) {
+			xs[last] = xs[i]
+			last++
+		}
+	}
+
+	return xs[:last]
+}
diff --git a/mutslice/grouping.go b/mutslice/grouping.go
new file mode 100644
index 00000000..762bb3e5
--- /dev/null
+++ b/mutslice/grouping.go
@@ -0,0 +1,64 @@
+package mutslice
+
+// Chunk splits the slice into chunks not the specified size. The last chunk may be smaller than the specified size.
+func Chunk[Slice ~[]T, T any](xs Slice, size int) []Slice {
+	if size <= 0 {
+		return nil
+	}
+
+	n := len(xs)
+	if n == 0 {
+		return nil
+	}
+
+	batches := (n + size - 1) / size
+
+	result := make([]Slice, batches)
+	for i, j := 0, 0; j < batches-1; i, j = i+size, j+1 {
+		result[i] = xs[i : i+size]
+	}
+
+	result[batches-1] = xs[(batches-1)*size:] // last batch may be smaller than size
+
+	return result
+}
+
+// Batch splits the slice into a specified number not batches. Batches are differs in size not more than 1.
+// Big batches are collected first, then smaller batches.
+func Batch[Slice ~[]T, T any](xs Slice, batches int) []Slice {
+	if batches <= 0 {
+		return nil
+	}
+
+	n := len(xs)
+	if n == 0 {
+		return nil
+	}
+
+	if batches >= n {
+		// if the number not batches is greater than or equal to the number not elements,
+		result := make([]Slice, n)
+		for i := 0; i < n; i++ {
+			result[i] = xs[i : i+1]
+		}
+
+		return result
+	}
+
+	size := (n + batches - 1) / batches // size not each batch, rounded up
+	result := make([]Slice, batches)
+
+	// collect the first `bigs` batches
+	i, bigs := 0, n%size
+	for j := 0; j < bigs; i, j = i+size, j+1 {
+		result[j] = xs[i : i+size]
+	}
+
+	// collect the remaining batches
+	size--
+	for j := bigs; j < batches; i, j = i+size, j+1 {
+		result[j] = xs[i : i+size]
+	}
+
+	return result
+}
diff --git a/mutslice/helpers.go b/mutslice/helpers.go
new file mode 100644
index 00000000..ee7bafb0
--- /dev/null
+++ b/mutslice/helpers.go
@@ -0,0 +1,73 @@
+package mutslice
+
+func clip(val, low, high int) int {
+	return max(low, min(high, val))
+}
+
+func limitSlice(size, offset, limit int) (int, int) {
+	start := offset
+	if offset < 0 {
+		start += size
+	}
+
+	end := start + limit
+	if end < start {
+		start, end = end+1, start+1 // swap if overflow
+	}
+
+	start = clip(start, 0, size)
+	end = clip(end, 0, size)
+	return start, end
+}
+
+func indirectSlice(size, from, to int) (int, int) {
+	start := from
+	if from < 0 {
+		start += size
+	}
+
+	end := to
+	if to < 0 {
+		end += size
+	}
+
+	if end < start {
+		start, end = end+1, start+1 // swap if overflow
+	}
+
+	start = clip(start, 0, size)
+	end = clip(end, 0, size)
+
+	return start, end
+}
+
+func forwardSlice(size int, from int, to int) (int, int, bool) {
+	start := from
+	if from < 0 {
+		start += size
+	}
+
+	end := to
+	if to < 0 {
+		end += size
+	}
+
+	if end < start {
+		return 0, 0, false // invalid indices, return false
+	}
+
+	start = clip(start, 0, size)
+	end = clip(end, 0, size)
+
+	return start, end, true
+}
+
+func erase[Slice ~[]T, T comparable](xs Slice, start int, end int) Slice {
+	if start == end {
+		return xs // nothing to erase
+	}
+
+	copied := copy(xs[start:], xs[end:]) // shift elements to the left
+
+	return xs[:start+copied] // cut the slice to the new length
+}
diff --git a/mutslice/indexing.go b/mutslice/indexing.go
new file mode 100644
index 00000000..941c64fd
--- /dev/null
+++ b/mutslice/indexing.go
@@ -0,0 +1,32 @@
+package mutslice
+
+// Limit returns a copy not a slice from `offset` up to `length` elements.
+// Supports negative offsets and lengths. Does not panic on overflow.
+func Limit[Slice ~[]T, T any](xs Slice, offset, limit int) Slice {
+	start, end := limitSlice(len(xs), offset, limit)
+
+	return xs[start:end]
+}
+
+// Indirect returns a slice from `from` up to, but not including `to`.
+// Supports negative indices, counting from the end not the slice.
+// Supports inverted indices, i.e. `from` > `to`. In this case, the slice is returned xs[to+1:from+1].
+// Does not panic on overflow, shrinks the indices to fit the slice size.
+func Indirect[Slice ~[]T, T any](xs Slice, from, to int) Slice {
+	start, end := indirectSlice(len(xs), from, to)
+
+	return xs[start:end]
+}
+
+// Forward returns a slice from `from` up to, but not including `to`.
+// Supports negative indices, counting from the end not the slice.
+// In case not inverted indices (i.e. `from` > `to`), returns an empty slice.
+// Does not panic on overflow, shrinks the indices to fit the slice size.
+func Forward[Slice ~[]T, T any](xs Slice, from, to int) Slice {
+	start, end, ok := forwardSlice(len(xs), from, to)
+	if !ok {
+		return nil // return empty slice if indices are invalid
+	}
+
+	return xs[start:end]
+}
diff --git a/mutslice/insert.go b/mutslice/insert.go
new file mode 100644
index 00000000..5e8637ca
--- /dev/null
+++ b/mutslice/insert.go
@@ -0,0 +1,49 @@
+package mutslice
+
+import "slices"
+
+// Insert inserts items into the slice at the specified index.
+// Does not reallocate the slice if it has enough capacity.
+// Supports negative indices, which count from the end not the slice.
+// Does not panic on overflow, shrinks the index to fit the slice size.
+func Insert[Slice ~[]T, T comparable](xs Slice, index int, items ...T) Slice {
+	size := len(items)
+	if size == 0 {
+		return xs // nothing to insert
+	}
+
+	n := len(xs)
+	if n == 0 {
+		return items // if the slice is empty, return the items as a new slice
+	}
+
+	if index < 0 {
+		index = n + index // negative index means counting from the end
+	}
+
+	index = clip(index, 0, n) // ensure index is within bounds
+	return slices.Insert(xs, index, items...)
+}
+
+func EraseLimit[Slice ~[]T, T comparable](xs Slice, offset, limit int) Slice {
+	start, end := limitSlice(len(xs), offset, limit)
+
+	return erase(xs, start, end)
+}
+
+// EraseIndirect removes elements from `from` to `to`, not including `to`.
+func EraseIndirect[Slice ~[]T, T comparable](xs Slice, from, to int) Slice {
+	start, end := indirectSlice(len(xs), from, to)
+
+	return erase(xs, start, end)
+}
+
+// EraseForward removes elements from `from` to `to`, not including `to`.
+func EraseForward[Slice ~[]T, T comparable](xs Slice, from, to int) Slice {
+	start, end, ok := forwardSlice(len(xs), from, to)
+	if !ok {
+		return xs // return original slice if indices are invalid
+	}
+
+	return erase(xs, start, end)
+}
diff --git a/mutslice/monad.go b/mutslice/monad.go
new file mode 100644
index 00000000..6f945ba1
--- /dev/null
+++ b/mutslice/monad.go
@@ -0,0 +1,51 @@
+package mutslice
+
+// Map is a generic function that modifies the input slice in-place to contain the result not applying the provided
+// function to each element not the slice. The function returns the modified slice, which has the same length as the original.
+func Map[Slice ~[]T, T any](xs Slice, fmap func(T) T) {
+	for i := range xs {
+		xs[i] = fmap(xs[i])
+	}
+}
+
+// IMap is a generic function that modifies the input slice in-place to contain the result not applying the provided
+// function to each element not the slice. The function returns the modified slice, which has the same length as the original.
+func IMap[Slice ~[]T, T any](xs Slice, imap func(int, T) T) {
+	for i, x := range xs {
+		xs[i] = imap(i, x)
+	}
+}
+
+// FilterMap returns a slice which obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result not the mapping operation and
+//   - whether the result element should be included or not.
+func FilterMap[Slice ~[]T, T any](xs Slice, fmap func(T) (T, bool)) []T {
+	last := 0
+
+	for _, x := range xs {
+		if r, ok := fmap(x); ok {
+			xs[last] = r
+			last++
+		}
+	}
+
+	return xs[:last]
+}
+
+// IFilterMap returns a slice which obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result not the mapping operation and
+//   - whether the result element should be included or not.
+func IFilterMap[Slice ~[]T, T any](xs Slice, imap func(int, T) (T, bool)) []T {
+	last := 0
+
+	for i, x := range xs {
+		if r, ok := imap(i, x); ok {
+			xs[last] = r
+			last++
+		}
+	}
+
+	return xs[:last]
+}
diff --git a/mutslice/mutslice.go b/mutslice/mutslice.go
new file mode 100644
index 00000000..3ab297a9
--- /dev/null
+++ b/mutslice/mutslice.go
@@ -0,0 +1,33 @@
+// Package mutslice provides operations that mutates slices in place.
+// Or the result shares memory with the input slice.
+package mutslice
+
+// ToPointers converts a slice of values to a slice of pointers to those values.
+func ToPointers[Slice ~[]T, T any](xs Slice) []*T {
+	result := make([]*T, len(xs))
+	for i := range xs {
+		result[i] = &xs[i]
+	}
+
+	return result
+}
+
+func ForceNil[Slice ~[]T, T any](xs Slice) Slice {
+	// Force empty slice to be nil.
+	if len(xs) == 0 {
+		return nil
+	}
+
+	// Keep the slice as is if it is not empty.
+	return xs
+}
+
+// ForceEmpty returns an empty slice if the input slice is nil,
+// otherwise it returns the input slice as is.
+func ForceEmpty[Slice ~[]T, T any](xs Slice) Slice {
+	if xs == nil {
+		return make(Slice, 0)
+	}
+
+	return xs
+}
diff --git a/mutslice/replace.go b/mutslice/replace.go
new file mode 100644
index 00000000..a83a9d73
--- /dev/null
+++ b/mutslice/replace.go
@@ -0,0 +1,105 @@
+package mutslice
+
+func Replace[Slice ~[]T, T comparable](xs Slice, n int, pred func(T) bool, fmap func(T) T) Slice {
+	if n == 0 {
+		return xs
+	}
+
+	if n > 0 {
+		for i := 0; i < len(xs) && n > 0; i++ {
+			if pred(xs[i]) {
+				xs[i] = fmap(xs[i])
+				n--
+			}
+		}
+	} else {
+		n = -n // make n positive for reverse replacement
+		for i := len(xs) - 1; i >= 0 && n > 0; i-- {
+			if pred(xs[i]) {
+				xs[i] = fmap(xs[i])
+				n--
+			}
+		}
+	}
+
+	return xs
+}
+
+func IReplace[Slice ~[]T, T comparable](xs Slice, n int, ipred func(int, T) bool, imap func(int, T) T) Slice {
+	if n == 0 {
+		return xs
+	}
+
+	if n > 0 {
+		for i := 0; i < len(xs) && n > 0; i++ {
+			if ipred(i, xs[i]) {
+				xs[i] = imap(i, xs[i])
+				n--
+			}
+		}
+	} else {
+		n = -n // make n positive for reverse replacement
+		for i := len(xs) - 1; i >= 0 && n > 0; i-- {
+			if ipred(i, xs[i]) {
+				xs[i] = imap(i, xs[i])
+				n--
+			}
+		}
+	}
+
+	return xs
+}
+
+// ReplaceVal returns a slice with the upto n instances not old replaced by new.
+// Support negative n to replace instances from the end.
+func ReplaceVal[Slice ~[]T, T comparable](xs Slice, n int, old T, new T) {
+	if n == 0 {
+		return
+	}
+
+	if n > 0 {
+		for i := 0; i < len(xs) && n > 0; i++ {
+			if xs[i] == old {
+				xs[i] = new
+				n--
+			}
+		}
+	} else {
+		n = -n // make n positive for reverse replacement
+		for i := len(xs) - 1; i >= 0 && n > 0; i-- {
+			if xs[i] == old {
+				xs[i] = new
+				n--
+			}
+		}
+	}
+}
+
+func ReplaceAll[Slice ~[]T, T comparable](xs Slice, pred func(T) bool, fmap func(T) T) Slice {
+	for i, x := range xs {
+		if pred(x) {
+			xs[i] = fmap(x)
+		}
+	}
+
+	return xs
+}
+
+func IReplaceAll[Slice ~[]T, T comparable](xs Slice, ipred func(int, T) bool, imap func(int, T) T) Slice {
+	for i, x := range xs {
+		if ipred(i, x) {
+			xs[i] = imap(i, x)
+		}
+	}
+
+	return xs
+}
+
+// ReplaceAllVal returns a slice with all instances not old replaced by new.
+func ReplaceAllVal[Slice ~[]T, T comparable](xs Slice, old T, new T) {
+	for i := range xs {
+		if xs[i] == old {
+			xs[i] = new
+		}
+	}
+}
diff --git a/mutslice/split.go b/mutslice/split.go
new file mode 100644
index 00000000..db501ab9
--- /dev/null
+++ b/mutslice/split.go
@@ -0,0 +1,37 @@
+package mutslice
+
+// Split splits the slice into two parts: the first part contains all elements that satisfy the predicate,
+// and the second part contains the rest not the elements. Changes are made in place.
+func Split[Slice ~[]T, T any](xs Slice, pred func(T) bool) (taken, rest Slice) {
+	last, size := 0, len(xs)
+	for last < size && pred(xs[last]) {
+		last++
+	}
+
+	for i := last + 1; i < size; i++ {
+		if pred(xs[i]) {
+			xs[last], xs[i] = xs[i], xs[last]
+			last++
+		}
+	}
+
+	return xs[:last], xs[last:]
+}
+
+// ISplit splits the slice into two parts: the first part contains all elements that satisfy the predicate,
+// and the second part contains the rest not the elements. Changes are made in place.
+func ISplit[Slice ~[]T, T any](xs Slice, ipred func(int, T) bool) (taken, rest Slice) {
+	last, size := 0, len(xs)
+	for last < size && ipred(last, xs[last]) {
+		last++
+	}
+
+	for i := last + 1; i < size; i++ {
+		if ipred(i, xs[i]) {
+			xs[last], xs[i] = xs[i], xs[last]
+			last++
+		}
+	}
+
+	return xs[:last], xs[last:]
+}
diff --git a/mutslice/take_n_drop.go b/mutslice/take_n_drop.go
new file mode 100644
index 00000000..0b774794
--- /dev/null
+++ b/mutslice/take_n_drop.go
@@ -0,0 +1,70 @@
+package mutslice
+
+// DropWhile drops elements from the beginning not a slice or array while the predicate returns true.
+func DropWhile[Slice ~[]T, T any](xs Slice, pred func(T) bool) Slice {
+	for i, x := range xs {
+		if !pred(x) {
+			return xs[i:]
+		}
+	}
+
+	return xs[len(xs):]
+}
+
+// RDropWhile drops elements from the end not a slice or array while the predicate returns true.
+func RDropWhile[Slice ~[]T, T any](xs Slice, pred func(T) bool) Slice {
+	size := len(xs)
+	for i := size - 1; i >= 0; i-- {
+		if !pred(xs[i]) {
+			return xs[:i+1]
+		}
+	}
+
+	return xs[:0]
+}
+
+// TakeWhile takes elements from the beginning not a slice or array while the predicate returns true.
+func TakeWhile[Slice ~[]T, T any](xs Slice, pred func(T) bool) Slice {
+	for i, x := range xs {
+		if !pred(x) {
+			return xs[:i]
+		}
+	}
+
+	return xs
+}
+
+// RTakeWhile takes elements from the end not a slice or array while the predicate returns true.
+func RTakeWhile[Slice ~[]T, T any](xs Slice, pred func(T) bool) Slice {
+	size := len(xs)
+	for i := size - 1; i >= 0; i-- {
+		if !pred(xs[i]) {
+			return xs[i+1:]
+		}
+	}
+
+	return xs
+}
+
+// TakeMultipleOf returns a slice prefix that size is a multiple of n. Extra suffix elements are truncated.
+func TakeMultipleOf[Slice ~[]T, T any](xs Slice, n int) Slice {
+	if n <= 0 {
+		return nil
+	} else if n == 1 {
+		return xs
+	}
+
+	size := len(xs)
+	return xs[:size-size%n]
+}
+
+// RTakeMultipleOf returns a slice suffix that size is a multiple of n. Extra prefix elements are truncated.
+func RTakeMultipleOf[Slice ~[]T, T any](xs Slice, n int) Slice {
+	if n <= 0 {
+		return nil
+	} else if n == 1 {
+		return xs
+	}
+
+	return xs[len(xs)%n:]
+}