go/fp-go
1
0
Fork 0
mirror of https://github.com/IBM/fp-go.git synced 2025-11-27 22:28:29 +02:00
Code Issues Releases Activity

fix: remove unnecesary indirection in E.TryCatch

Browse Source 
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
2023-10-23 08:25:45 +02:00
parent 83a0c6cdef
commit 08d9fed9af
34 changed files with 11163 additions and 11528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
cli/either.go
View File

@@ -115,16 +115,14 @@ func generateEitherize(f *os.File, i int) {
fmt.Fprintf(f, "t%d T%d", j, j)
}
fmt.Fprintf(f, ") Either[error, R] {\n")
fmt.Fprintf(f, " return TryCatchError(func() (R, error) {\n")
fmt.Fprintf(f, " return f(")
fmt.Fprintf(f, " return TryCatchError(f(")
for j := 0; j < i; j++ {
if j > 0 {
fmt.Fprintf(f, ", ")
}
fmt.Fprintf(f, "t%d", j)
}
fmt.Fprintln(f, ")")
fmt.Fprintln(f, " })")
fmt.Fprintln(f, "))")
fmt.Fprintln(f, " }")
fmt.Fprintln(f, "}")
}

4
context/readereither/exec/exec.go
View File

@@ -34,8 +34,6 @@ var (
func command(name string, args []string, in []byte) RE.ReaderEither[exec.CommandOutput] {
return func(ctx context.Context) E.Either[error, exec.CommandOutput] {
return E.TryCatchError(func() (exec.CommandOutput, error) {
return GE.Exec(ctx, name, args, in)
})
return E.TryCatchError(GE.Exec(ctx, name, args, in))
}
}

3
context/readerioeither/gen.go
View File

@@ -2,7 +2,8 @@ package readerioeither
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:14.1022311 +0200 CEST m=+0.017763401
// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
import (
"context"

5
context/readerioeither/generic/gen.go
View File

@@ -2,14 +2,15 @@ package generic
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:14.1036885 +0200 CEST m=+0.019220801
// 2023-10-23 08:30:39.012572 +0200 CEST m=+0.008846101
import (
"context"
E "github.com/IBM/fp-go/either"
A "github.com/IBM/fp-go/internal/apply"
RE "github.com/IBM/fp-go/readerioeither/generic"
A "github.com/IBM/fp-go/internal/apply"
T "github.com/IBM/fp-go/tuple"
)

11
either/either.go
View File

@@ -120,16 +120,15 @@ func Flatten[E, A any](mma Either[E, Either[E, A]]) Either[E, A] {
return MonadChain(mma, F.Identity[Either[E, A]])
}
func TryCatch[FA ~func() (A, error), FE func(error) E, E, A any](f FA, onThrow FE) Either[E, A] {
val, err := f()
func TryCatch[FE func(error) E, E, A any](val A, err error, onThrow FE) Either[E, A] {
if err != nil {
return F.Pipe2(err, onThrow, Left[A, E])
}
return F.Pipe1(val, Right[E, A])
}
func TryCatchError[F ~func() (A, error), A any](f F) Either[error, A] {
return TryCatch(f, E.IdentityError)
func TryCatchError[A any](val A, err error) Either[error, A] {
return TryCatch(val, err, E.IdentityError)
}
func Sequence2[E, T1, T2, R any](f func(T1, T2) Either[E, R]) func(Either[E, T1], Either[E, T2]) Either[E, R] {
@@ -154,9 +153,7 @@ func ToOption[E, A any](ma Either[E, A]) O.Option[A] {
func FromError[A any](f func(a A) error) func(A) Either[error, A] {
return func(a A) Either[error, A] {
return TryCatchError(func() (A, error) {
return a, f(a)
})
return TryCatchError(a, f(a))
}
}

4
either/exec/exec.go
View File

@@ -32,7 +32,5 @@ var (
)
func command(name string, args []string, in []byte) E.Either[error, exec.CommandOutput] {
return E.TryCatchError(func() (exec.CommandOutput, error) {
return GE.Exec(context.Background(), name, args, in)
})
return E.TryCatchError(GE.Exec(context.Background(), name, args, in))
}

47
either/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:15.6356542 +0200 CEST m=+0.009418901
// 2023-10-23 08:30:40.410373 +0200 CEST m=+0.010337601
package either
import (
A "github.com/IBM/fp-go/internal/apply"
T "github.com/IBM/fp-go/tuple"
@@ -13,9 +14,7 @@ import (
// The inverse function is [Uneitherize0]
func Eitherize0[F ~func() (R, error), R any](f F) func() Either[error, R] {
return func() Either[error, R] {
return TryCatchError(func() (R, error) {
return f()
})
return TryCatchError(f())
}
}
@@ -31,9 +30,7 @@ func Uneitherize0[F ~func() Either[error, R], R any](f F) func() (R, error) {
// The inverse function is [Uneitherize1]
func Eitherize1[F ~func(T0) (R, error), T0, R any](f F) func(T0) Either[error, R] {
return func(t0 T0) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0)
})
return TryCatchError(f(t0))
}
}
@@ -76,9 +73,7 @@ func TraverseTuple1[F1 ~func(A1) Either[E, T1], E, A1, T1 any](f1 F1) func(T.Tup
// The inverse function is [Uneitherize2]
func Eitherize2[F ~func(T0, T1) (R, error), T0, T1, R any](f F) func(T0, T1) Either[error, R] {
return func(t0 T0, t1 T1) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1)
})
return TryCatchError(f(t0, t1))
}
}
@@ -126,9 +121,7 @@ func TraverseTuple2[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], E, A
// The inverse function is [Uneitherize3]
func Eitherize3[F ~func(T0, T1, T2) (R, error), T0, T1, T2, R any](f F) func(T0, T1, T2) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2)
})
return TryCatchError(f(t0, t1, t2))
}
}
@@ -181,9 +174,7 @@ func TraverseTuple3[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize4]
func Eitherize4[F ~func(T0, T1, T2, T3) (R, error), T0, T1, T2, T3, R any](f F) func(T0, T1, T2, T3) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3)
})
return TryCatchError(f(t0, t1, t2, t3))
}
}
@@ -241,9 +232,7 @@ func TraverseTuple4[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize5]
func Eitherize5[F ~func(T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, R any](f F) func(T0, T1, T2, T3, T4) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3, t4)
})
return TryCatchError(f(t0, t1, t2, t3, t4))
}
}
@@ -306,9 +295,7 @@ func TraverseTuple5[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize6]
func Eitherize6[F ~func(T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T4, T5, R any](f F) func(T0, T1, T2, T3, T4, T5) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3, t4, t5)
})
return TryCatchError(f(t0, t1, t2, t3, t4, t5))
}
}
@@ -376,9 +363,7 @@ func TraverseTuple6[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize7]
func Eitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T3, T4, T5, T6, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3, t4, t5, t6)
})
return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6))
}
}
@@ -451,9 +436,7 @@ func TraverseTuple7[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize8]
func Eitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3, t4, t5, t6, t7)
})
return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7))
}
}
@@ -531,9 +514,7 @@ func TraverseTuple8[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize9]
func Eitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3, t4, t5, t6, t7, t8)
})
return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8))
}
}
@@ -616,9 +597,7 @@ func TraverseTuple9[F1 ~func(A1) Either[E, T1], F2 ~func(A2) Either[E, T2], F3 ~
// The inverse function is [Uneitherize10]
func Eitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) Either[error, R] {
return func(t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
})
return TryCatchError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
}
}

8
either/http/request.go
View File

@@ -35,17 +35,13 @@ var (
func bodyRequest(method string) func(string) func([]byte) E.Either[error, *http.Request] {
return func(url string) func([]byte) E.Either[error, *http.Request] {
return func(body []byte) E.Either[error, *http.Request] {
return E.TryCatchError(func() (*http.Request, error) {
return http.NewRequest(method, url, bytes.NewReader(body))
})
return E.TryCatchError(http.NewRequest(method, url, bytes.NewReader(body)))
}
}
}
func noBodyRequest(method string) func(string) E.Either[error, *http.Request] {
return func(url string) E.Either[error, *http.Request] {
return E.TryCatchError(func() (*http.Request, error) {
return http.NewRequest(method, url, nil)
})
return E.TryCatchError(http.NewRequest(method, url, nil))
}
}

12
either/resource_test.go
View File

@@ -25,20 +25,14 @@ import (
func TestWithResource(t *testing.T) {
onCreate := func() Either[error, *os.File] {
return TryCatchError(func() (*os.File, error) {
return os.CreateTemp("", "*")
})
return TryCatchError(os.CreateTemp("", "*"))
}
onDelete := F.Flow2(
func(f *os.File) Either[error, string] {
return TryCatchError(func() (string, error) {
return f.Name(), f.Close()
})
return TryCatchError(f.Name(), f.Close())
},
Chain(func(name string) Either[error, any] {
return TryCatchError(func() (any, error) {
return name, os.Remove(name)
})
return TryCatchError(any(name), os.Remove(name))
}),
)

40
either/variadic.go
View File

@@ -17,80 +17,60 @@ package either
func Variadic0[V, R any](f func([]V) (R, error)) func(...V) Either[error, R] {
return func(v ...V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(v)
})
return TryCatchError(f(v))
}
}
func Variadic1[T1, V, R any](f func(T1, []V) (R, error)) func(T1, ...V) Either[error, R] {
return func(t1 T1, v ...V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, v)
})
return TryCatchError(f(t1, v))
}
}
func Variadic2[T1, T2, V, R any](f func(T1, T2, []V) (R, error)) func(T1, T2, ...V) Either[error, R] {
return func(t1 T1, t2 T2, v ...V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, t2, v)
})
return TryCatchError(f(t1, t2, v))
}
}
func Variadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, []V) (R, error)) func(T1, T2, T3, ...V) Either[error, R] {
return func(t1 T1, t2 T2, t3 T3, v ...V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, t2, t3, v)
})
return TryCatchError(f(t1, t2, t3, v))
}
}
func Variadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, []V) (R, error)) func(T1, T2, T3, T4, ...V) Either[error, R] {
return func(t1 T1, t2 T2, t3 T3, t4 T4, v ...V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, t2, t3, t4, v)
})
return TryCatchError(f(t1, t2, t3, t4, v))
}
}
func Unvariadic0[V, R any](f func(...V) (R, error)) func([]V) Either[error, R] {
return func(v []V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(v...)
})
return TryCatchError(f(v...))
}
}
func Unvariadic1[T1, V, R any](f func(T1, ...V) (R, error)) func(T1, []V) Either[error, R] {
return func(t1 T1, v []V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, v...)
})
return TryCatchError(f(t1, v...))
}
}
func Unvariadic2[T1, T2, V, R any](f func(T1, T2, ...V) (R, error)) func(T1, T2, []V) Either[error, R] {
return func(t1 T1, t2 T2, v []V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, t2, v...)
})
return TryCatchError(f(t1, t2, v...))
}
}
func Unvariadic3[T1, T2, T3, V, R any](f func(T1, T2, T3, ...V) (R, error)) func(T1, T2, T3, []V) Either[error, R] {
return func(t1 T1, t2 T2, t3 T3, v []V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, t2, t3, v...)
})
return TryCatchError(f(t1, t2, t3, v...))
}
}
func Unvariadic4[T1, T2, T3, T4, V, R any](f func(T1, T2, T3, T4, ...V) (R, error)) func(T1, T2, T3, T4, []V) Either[error, R] {
return func(t1 T1, t2 T2, t3 T3, t4 T4, v []V) Either[error, R] {
return TryCatchError(func() (R, error) {
return f(t1, t2, t3, t4, v...)
})
return TryCatchError(f(t1, t2, t3, t4, v...))
}
}

6
function/binds.go
View File

@@ -1,9 +1,8 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:23.4226437 +0200 CEST m=+0.011841001
// 2023-10-23 08:30:44.6474482 +0200 CEST m=+0.150851901
package function
// Combinations for a total of 1 arguments
// Bind1of1 takes a function with 1 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -22,7 +21,6 @@ func Ignore1of1[T1 any, F ~func() R, R any](f F) func(T1) R {
return f()
}
}
// Combinations for a total of 2 arguments
// Bind1of2 takes a function with 2 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -75,7 +73,6 @@ func Ignore12of2[T1, T2 any, F ~func() R, R any](f F) func(T1, T2) R {
return f()
}
}
// Combinations for a total of 3 arguments
// Bind1of3 takes a function with 3 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.
@@ -196,7 +193,6 @@ func Ignore123of3[T1, T2, T3 any, F ~func() R, R any](f F) func(T1, T2, T3) R {
return f()
}
}
// Combinations for a total of 4 arguments
// Bind1of4 takes a function with 4 parameters and returns a new function with 1 parameters that will bind these parameters to the positions [1] of the original function.

2
function/gen.go
View File

@@ -1,6 +1,6 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:17.0002767 +0200 CEST m=+0.008233101
// 2023-10-23 08:30:41.7972101 +0200 CEST m=+0.008029101
package function

4
http/utils.go
View File

@@ -68,10 +68,8 @@ const (
// ParseMediaType parses a media type into a tuple
func ParseMediaType(mediaType string) E.Either[error, ParsedMediaType] {
return E.TryCatchError(func() (ParsedMediaType, error) {
m, p, err := mime.ParseMediaType(mediaType)
return T.MakeTuple2(m, p), err
})
return E.TryCatchError(T.MakeTuple2(m, p), err)
}
func GetHeader(resp *H.Response) H.Header {

3
identity/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:24.9409324 +0200 CEST m=+0.008573601
// 2023-10-23 08:30:50.5492271 +0200 CEST m=+0.023274501
package identity
import (
A "github.com/IBM/fp-go/internal/apply"
T "github.com/IBM/fp-go/tuple"

3
internal/apply/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:26.2499883 +0200 CEST m=+0.007601301
// 2023-10-23 08:30:54.1909432 +0200 CEST m=+0.014252201
package apply
import (
F "github.com/IBM/fp-go/function"
T "github.com/IBM/fp-go/tuple"

4
internal/file/file.go
View File

@@ -46,9 +46,7 @@ func MakeReader(ctx context.Context, rdr io.Reader) io.Reader {
// ReadAll reads the content of a reader and allows it to be canceled
func ReadAll(ctx context.Context, rdr io.Reader) E.Either[error, []byte] {
return E.TryCatchError(func() ([]byte, error) {
var buffer bytes.Buffer
_, err := io.Copy(&buffer, MakeReader(ctx, rdr))
return buffer.Bytes(), err
})
return E.TryCatchError(buffer.Bytes(), err)
}

3
io/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:27.9813739 +0200 CEST m=+0.011088001
// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
package io
import (
G "github.com/IBM/fp-go/io/generic"
T "github.com/IBM/fp-go/tuple"

5
io/generic/gen.go
View File

@@ -1,11 +1,12 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:27.9813739 +0200 CEST m=+0.011088001
// 2023-10-23 08:30:56.7105551 +0200 CEST m=+0.011255201
package generic
import (
A "github.com/IBM/fp-go/internal/apply"
T "github.com/IBM/fp-go/tuple"
A "github.com/IBM/fp-go/internal/apply"
)
// SequenceT1 converts 1 [func() T] into a [func() T.Tuple1[T1]]

3
io/sync.go
View File

@@ -19,10 +19,9 @@ import (
"context"
G "github.com/IBM/fp-go/io/generic"
L "github.com/IBM/fp-go/lazy"
)
// WithLock executes the provided [IO] operation in the scope of a lock
func WithLock[A any](lock L.Lazy[context.CancelFunc]) func(fa IO[A]) IO[A] {
func WithLock[A any](lock IO[context.CancelFunc]) func(fa IO[A]) IO[A] {
return G.WithLock[IO[A]](lock)
}

3
ioeither/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:29.4935658 +0200 CEST m=+0.015377401
// 2023-10-23 08:30:58.6457744 +0200 CEST m=+0.080336501
package ioeither
import (
G "github.com/IBM/fp-go/ioeither/generic"
T "github.com/IBM/fp-go/tuple"

38
ioeither/generic/gen.go
View File

@@ -1,12 +1,13 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:29.4935658 +0200 CEST m=+0.015377401
// 2023-10-23 08:30:58.6556525 +0200 CEST m=+0.090214601
package generic
import (
ET "github.com/IBM/fp-go/either"
A "github.com/IBM/fp-go/internal/apply"
T "github.com/IBM/fp-go/tuple"
A "github.com/IBM/fp-go/internal/apply"
)
// Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
@@ -15,8 +16,7 @@ func Eitherize0[GIOA ~func() ET.Either[error, R], F ~func() (R, error), R any](f
return func() GIOA {
return func() ET.Either[error, R] {
return e()
}
}
}}
}
// Uneitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
@@ -32,8 +32,7 @@ func Eitherize1[GIOA ~func() ET.Either[error, R], F ~func(T1) (R, error), T1, R
return func(t1 T1) GIOA {
return func() ET.Either[error, R] {
return e(t1)
}
}
}}
}
// Uneitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
@@ -86,8 +85,7 @@ func Eitherize2[GIOA ~func() ET.Either[error, R], F ~func(T1, T2) (R, error), T1
return func(t1 T1, t2 T2) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2)
}
}
}}
}
// Uneitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
@@ -150,8 +148,7 @@ func Eitherize3[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3) (R, error)
return func(t1 T1, t2 T2, t3 T3) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3)
}
}
}}
}
// Uneitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
@@ -224,8 +221,7 @@ func Eitherize4[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4) (R, er
return func(t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4)
}
}
}}
}
// Uneitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
@@ -308,8 +304,7 @@ func Eitherize5[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5) (R
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5)
}
}
}}
}
// Uneitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
@@ -402,8 +397,7 @@ func Eitherize6[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6)
}
}
}}
}
// Uneitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
@@ -506,8 +500,7 @@ func Eitherize7[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7)
}
}
}}
}
// Uneitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
@@ -620,8 +613,7 @@ func Eitherize8[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8)
}
}
}}
}
// Uneitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
@@ -744,8 +736,7 @@ func Eitherize9[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8, t9)
}
}
}}
}
// Uneitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
@@ -878,8 +869,7 @@ func Eitherize10[GIOA ~func() ET.Either[error, R], F ~func(T1, T2, T3, T4, T5, T
return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) GIOA {
return func() ET.Either[error, R] {
return e(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
}
}
}}
}
// Uneitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]

8
ioeither/generic/ioeither.go
View File

@@ -19,7 +19,6 @@ import (
"time"
ET "github.com/IBM/fp-go/either"
"github.com/IBM/fp-go/errors"
F "github.com/IBM/fp-go/function"
C "github.com/IBM/fp-go/internal/chain"
"github.com/IBM/fp-go/internal/eithert"
@@ -184,12 +183,15 @@ func Flatten[GA ~func() ET.Either[E, A], GAA ~func() ET.Either[E, GA], E, A any]
func TryCatch[GA ~func() ET.Either[E, A], E, A any](f func() (A, error), onThrow func(error) E) GA {
return MakeIO(func() ET.Either[E, A] {
return ET.TryCatch(f, onThrow)
a, err := f()
return ET.TryCatch(a, err, onThrow)
})
}
func TryCatchError[GA ~func() ET.Either[error, A], A any](f func() (A, error)) GA {
return TryCatch[GA](f, errors.IdentityError)
return MakeIO(func() ET.Either[error, A] {
return ET.TryCatchError(f())
})
}
// Memoize computes the value of the provided IO monad lazily but exactly once

4
ioeither/sync.go
View File

@@ -18,11 +18,11 @@ package ioeither
import (
"context"
IO "github.com/IBM/fp-go/io"
G "github.com/IBM/fp-go/ioeither/generic"
L "github.com/IBM/fp-go/lazy"
)
// WithLock executes the provided IO operation in the scope of a lock
func WithLock[E, A any](lock L.Lazy[context.CancelFunc]) func(fa IOEither[E, A]) IOEither[E, A] {
func WithLock[E, A any](lock IO.IO[context.CancelFunc]) func(fa IOEither[E, A]) IOEither[E, A] {
return G.WithLock[IOEither[E, A]](lock)
}

3
iooption/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:32.1514823 +0200 CEST m=+0.098931001
// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901
package iooption
import (
G "github.com/IBM/fp-go/iooption/generic"
T "github.com/IBM/fp-go/tuple"

7
iooption/generic/gen.go
View File

@@ -1,12 +1,13 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:32.1546277 +0200 CEST m=+0.102076401
// 2023-10-23 08:31:01.9227118 +0200 CEST m=+0.009977901
package generic
import (
A "github.com/IBM/fp-go/internal/apply"
O "github.com/IBM/fp-go/option"
T "github.com/IBM/fp-go/tuple"
O "github.com/IBM/fp-go/option"
A "github.com/IBM/fp-go/internal/apply"
)
// SequenceT1 converts 1 [func() O.Option[T]] into a [func() O.Option[T.Tuple1[T1]]]

4
iooption/sync.go
View File

@@ -18,11 +18,11 @@ package iooption
import (
"context"
IO "github.com/IBM/fp-go/io"
G "github.com/IBM/fp-go/iooption/generic"
L "github.com/IBM/fp-go/lazy"
)
// WithLock executes the provided IO operation in the scope of a lock
func WithLock[E, A any](lock L.Lazy[context.CancelFunc]) func(fa IOOption[A]) IOOption[A] {
func WithLock[E, A any](lock IO.IO[context.CancelFunc]) func(fa IOOption[A]) IOOption[A] {
return G.WithLock[IOOption[A]](lock)
}

8
json/json.go
View File

@@ -23,16 +23,12 @@ import (
// Unmarshal parses a JSON data structure from bytes
func Unmarshal[A any](data []byte) E.Either[error, A] {
return E.TryCatchError(func() (A, error) {
var result A
err := json.Unmarshal(data, &result)
return result, err
})
return E.TryCatchError(result, err)
}
// Marshal converts a data structure to json
func Marshal[A any](a A) E.Either[error, []byte] {
return E.TryCatchError(func() ([]byte, error) {
return json.Marshal(a)
})
return E.TryCatchError(json.Marshal(a))
}

4
option/gen.go
View File

@@ -1,14 +1,14 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:34.2077257 +0200 CEST m=+0.023541001
// 2023-10-23 08:31:07.8687134 +0200 CEST m=+0.012222901
package option
import (
A "github.com/IBM/fp-go/internal/apply"
T "github.com/IBM/fp-go/tuple"
)
// optionize converts a nullary function to an option
func optionize[R any](f func() (R, bool)) Option[R] {
if r, ok := f(); ok {

3
reader/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:36.1655251 +0200 CEST m=+0.010000501
// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501
package reader
import (
G "github.com/IBM/fp-go/reader/generic"
)

3
reader/generic/gen.go
View File

@@ -1,8 +1,9 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:36.166526 +0200 CEST m=+0.011001401
// 2023-10-23 08:31:13.0131834 +0200 CEST m=+0.010996501
package generic
// From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]
// The first parameter is considered to be the context [C].
func From0[GRA ~func(C) R, F ~func(C) R, C, R any](f F) func() GRA {

3
readerioeither/gen.go
View File

@@ -1,9 +1,10 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:37.5566477 +0200 CEST m=+0.009011201
// 2023-10-23 08:31:16.2414489 +0200 CEST m=+0.013052301
package readerioeither
import (
G "github.com/IBM/fp-go/readerioeither/generic"
)

36
readerioeither/generic/gen.go
View File

@@ -1,8 +1,9 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:37.5566477 +0200 CEST m=+0.009011201
// 2023-10-23 08:31:16.241979 +0200 CEST m=+0.013582401
package generic
import (
E "github.com/IBM/fp-go/either"
RD "github.com/IBM/fp-go/reader/generic"
@@ -22,8 +23,7 @@ func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[
return From0[GRA](func(r C) func() (R, error) {
return func() (R, error) {
return f(r)
}
})
}})
}
// From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
@@ -40,8 +40,7 @@ func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Eit
return From1[GRA](func(r C, t0 T0) func() (R, error) {
return func() (R, error) {
return f(r, t0)
}
})
}})
}
// From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
@@ -58,8 +57,7 @@ func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E
return From2[GRA](func(r C, t0 T0, t1 T1) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1)
}
})
}})
}
// From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
@@ -76,8 +74,7 @@ func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func
return From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2)
}
})
}})
}
// From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
@@ -94,8 +91,7 @@ func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~
return From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3)
}
})
}})
}
// From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
@@ -112,8 +108,7 @@ func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GI
return From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4)
}
})
}})
}
// From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
@@ -130,8 +125,7 @@ func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error)
return From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5)
}
})
}})
}
// From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
@@ -148,8 +142,7 @@ func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, er
return From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6)
}
})
}})
}
// From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
@@ -166,8 +159,7 @@ func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R
return From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7)
}
})
}})
}
// From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
@@ -184,8 +176,7 @@ func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8
return From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8)
}
})
}})
}
// From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
@@ -202,6 +193,5 @@ func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T
return From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) func() (R, error) {
return func() (R, error) {
return f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)
}
})
}})
}

4
samples/tuples/tuple_test.go
View File

@@ -58,10 +58,8 @@ func TestSampleConvertDocx2(t *testing.T) {
// The disadvantage is that its input has to exist in memory which is probably not a good
// idea for large inputs
convertDocx := func(data []byte) E.Either[error, T.Tuple2[string, map[string]string]] {
return E.TryCatchError(func() (T.Tuple2[string, map[string]string], error) {
text, meta, err := sampleConvertDocx(bytes.NewReader(data))
return T.MakeTuple2(text, meta), err
})
return E.TryCatchError(T.MakeTuple2(text, meta), err)
}
resE := convertDocx([]byte("abc"))

548
tuple/gen.go
View File

@@ -1,12 +1,13 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-09-12 13:44:39.7573676 +0200 CEST m=+0.040374701
// 2023-10-23 08:31:19.0449107 +0200 CEST m=+0.023307601
package tuple
import (
"encoding/json"
"fmt"
"encoding/json"
M "github.com/IBM/fp-go/monoid"
O "github.com/IBM/fp-go/ord"
)
@@ -137,9 +138,7 @@ func Monoid1[T1 any](m1 M.Monoid[T1]) M.Monoid[Tuple1[T1]] {
// Ord1 creates n [Ord] for a [Tuple1] based on 1 [Ord]s for the contained types
func Ord1[T1 any](o1 O.Ord[T1]) O.Ord[Tuple1[T1]] {
return O.MakeOrd(func(l, r Tuple1[T1]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
return 0
}, func(l, r Tuple1[T1]) bool {
return o1.Equals(l.F1, r.F1)
@@ -173,14 +172,10 @@ func (t Tuple1[T1]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple1]
func (t *Tuple1[T1]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
}
return nil
}
@@ -243,12 +238,8 @@ func Monoid2[T1, T2 any](m1 M.Monoid[T1], m2 M.Monoid[T2]) M.Monoid[Tuple2[T1, T
// Ord2 creates n [Ord] for a [Tuple2] based on 2 [Ord]s for the contained types
func Ord2[T1, T2 any](o1 O.Ord[T1], o2 O.Ord[T2]) O.Ord[Tuple2[T1, T2]] {
return O.MakeOrd(func(l, r Tuple2[T1, T2]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
return 0
}, func(l, r Tuple2[T1, T2]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2)
@@ -283,20 +274,13 @@ func (t Tuple2[T1, T2]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple2]
func (t *Tuple2[T1, T2]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
}
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
}}
return nil
}
@@ -360,15 +344,9 @@ func Monoid3[T1, T2, T3 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T3])
// Ord3 creates n [Ord] for a [Tuple3] based on 3 [Ord]s for the contained types
func Ord3[T1, T2, T3 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3]) O.Ord[Tuple3[T1, T2, T3]] {
return O.MakeOrd(func(l, r Tuple3[T1, T2, T3]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
return 0
}, func(l, r Tuple3[T1, T2, T3]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3)
@@ -404,25 +382,15 @@ func (t Tuple3[T1, T2, T3]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple3]
func (t *Tuple3[T1, T2, T3]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
}
}
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
}}}
return nil
}
@@ -488,18 +456,10 @@ func Monoid4[T1, T2, T3, T4 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Monoid[T
// Ord4 creates n [Ord] for a [Tuple4] based on 4 [Ord]s for the contained types
func Ord4[T1, T2, T3, T4 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4]) O.Ord[Tuple4[T1, T2, T3, T4]] {
return O.MakeOrd(func(l, r Tuple4[T1, T2, T3, T4]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
return 0
}, func(l, r Tuple4[T1, T2, T3, T4]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4)
@@ -536,30 +496,17 @@ func (t Tuple4[T1, T2, T3, T4]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple4]
func (t *Tuple4[T1, T2, T3, T4]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
}
}
}
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
}}}}
return nil
}
@@ -627,21 +574,11 @@ func Monoid5[T1, T2, T3, T4, T5 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.Mono
// Ord5 creates n [Ord] for a [Tuple5] based on 5 [Ord]s for the contained types
func Ord5[T1, T2, T3, T4, T5 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5]) O.Ord[Tuple5[T1, T2, T3, T4, T5]] {
return O.MakeOrd(func(l, r Tuple5[T1, T2, T3, T4, T5]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c := o5.Compare(l.F5, r.F5); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
return 0
}, func(l, r Tuple5[T1, T2, T3, T4, T5]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5)
@@ -679,35 +616,19 @@ func (t Tuple5[T1, T2, T3, T4, T5]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple5]
func (t *Tuple5[T1, T2, T3, T4, T5]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
if l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
}
}
}
}
}
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
}}}}}
return nil
}
@@ -777,24 +698,12 @@ func Monoid6[T1, T2, T3, T4, T5, T6 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m3 M.
// Ord6 creates n [Ord] for a [Tuple6] based on 6 [Ord]s for the contained types
func Ord6[T1, T2, T3, T4, T5, T6 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6]) O.Ord[Tuple6[T1, T2, T3, T4, T5, T6]] {
return O.MakeOrd(func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c := o5.Compare(l.F5, r.F5); c != 0 {
return c
}
if c := o6.Compare(l.F6, r.F6); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
return 0
}, func(l, r Tuple6[T1, T2, T3, T4, T5, T6]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6)
@@ -833,40 +742,21 @@ func (t Tuple6[T1, T2, T3, T4, T5, T6]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple6]
func (t *Tuple6[T1, T2, T3, T4, T5, T6]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
if l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
if l > 5 {
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
return err
}
}
}
}
}
}
}
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
}}}}}}
return nil
}
@@ -938,27 +828,13 @@ func Monoid7[T1, T2, T3, T4, T5, T6, T7 any](m1 M.Monoid[T1], m2 M.Monoid[T2], m
// Ord7 creates n [Ord] for a [Tuple7] based on 7 [Ord]s for the contained types
func Ord7[T1, T2, T3, T4, T5, T6, T7 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7]) O.Ord[Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
return O.MakeOrd(func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c := o5.Compare(l.F5, r.F5); c != 0 {
return c
}
if c := o6.Compare(l.F6, r.F6); c != 0 {
return c
}
if c := o7.Compare(l.F7, r.F7); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
return 0
}, func(l, r Tuple7[T1, T2, T3, T4, T5, T6, T7]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7)
@@ -998,45 +874,23 @@ func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple7]
func (t *Tuple7[T1, T2, T3, T4, T5, T6, T7]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
if l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
if l > 5 {
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
return err
}
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
if l > 6 {
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
return err
}
}
}
}
}
}
}
}
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
}}}}}}}
return nil
}
@@ -1110,30 +964,14 @@ func Monoid8[T1, T2, T3, T4, T5, T6, T7, T8 any](m1 M.Monoid[T1], m2 M.Monoid[T2
// Ord8 creates n [Ord] for a [Tuple8] based on 8 [Ord]s for the contained types
func Ord8[T1, T2, T3, T4, T5, T6, T7, T8 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8]) O.Ord[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
return O.MakeOrd(func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c := o5.Compare(l.F5, r.F5); c != 0 {
return c
}
if c := o6.Compare(l.F6, r.F6); c != 0 {
return c
}
if c := o7.Compare(l.F7, r.F7); c != 0 {
return c
}
if c := o8.Compare(l.F8, r.F8); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
return 0
}, func(l, r Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8)
@@ -1174,50 +1012,25 @@ func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals a JSON array into a [Tuple8]
func (t *Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
if l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
if l > 5 {
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
return err
}
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
if l > 6 {
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
return err
}
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
if l > 7 {
if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
return err
}
}
}
}
}
}
}
}
}
if err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
}}}}}}}}
return nil
}
@@ -1293,33 +1106,15 @@ func Monoid9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](m1 M.Monoid[T1], m2 M.Monoi
// Ord9 creates n [Ord] for a [Tuple9] based on 9 [Ord]s for the contained types
func Ord9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9]) O.Ord[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
return O.MakeOrd(func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c := o5.Compare(l.F5, r.F5); c != 0 {
return c
}
if c := o6.Compare(l.F6, r.F6); c != 0 {
return c
}
if c := o7.Compare(l.F7, r.F7); c != 0 {
return c
}
if c := o8.Compare(l.F8, r.F8); c != 0 {
return c
}
if c := o9.Compare(l.F9, r.F9); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
return 0
}, func(l, r Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9)
@@ -1361,55 +1156,27 @@ func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) MarshalJSON() ([]byte, error
// UnmarshalJSON unmarshals a JSON array into a [Tuple9]
func (t *Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
if l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
if l > 5 {
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
return err
}
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
if l > 6 {
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
return err
}
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
if l > 7 {
if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
return err
}
if err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
if l > 8 {
if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
return err
}
}
}
}
}
}
}
}
}
}
if err := json.Unmarshal(tmp[8], &t.F9); err != nil {return err}
}}}}}}}}}
return nil
}
@@ -1487,36 +1254,16 @@ func Monoid10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](m1 M.Monoid[T1], m2 M
// Ord10 creates n [Ord] for a [Tuple10] based on 10 [Ord]s for the contained types
func Ord10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](o1 O.Ord[T1], o2 O.Ord[T2], o3 O.Ord[T3], o4 O.Ord[T4], o5 O.Ord[T5], o6 O.Ord[T6], o7 O.Ord[T7], o8 O.Ord[T8], o9 O.Ord[T9], o10 O.Ord[T10]) O.Ord[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
return O.MakeOrd(func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) int {
if c := o1.Compare(l.F1, r.F1); c != 0 {
return c
}
if c := o2.Compare(l.F2, r.F2); c != 0 {
return c
}
if c := o3.Compare(l.F3, r.F3); c != 0 {
return c
}
if c := o4.Compare(l.F4, r.F4); c != 0 {
return c
}
if c := o5.Compare(l.F5, r.F5); c != 0 {
return c
}
if c := o6.Compare(l.F6, r.F6); c != 0 {
return c
}
if c := o7.Compare(l.F7, r.F7); c != 0 {
return c
}
if c := o8.Compare(l.F8, r.F8); c != 0 {
return c
}
if c := o9.Compare(l.F9, r.F9); c != 0 {
return c
}
if c := o10.Compare(l.F10, r.F10); c != 0 {
return c
}
if c:= o1.Compare(l.F1, r.F1); c != 0 {return c}
if c:= o2.Compare(l.F2, r.F2); c != 0 {return c}
if c:= o3.Compare(l.F3, r.F3); c != 0 {return c}
if c:= o4.Compare(l.F4, r.F4); c != 0 {return c}
if c:= o5.Compare(l.F5, r.F5); c != 0 {return c}
if c:= o6.Compare(l.F6, r.F6); c != 0 {return c}
if c:= o7.Compare(l.F7, r.F7); c != 0 {return c}
if c:= o8.Compare(l.F8, r.F8); c != 0 {return c}
if c:= o9.Compare(l.F9, r.F9); c != 0 {return c}
if c:= o10.Compare(l.F10, r.F10); c != 0 {return c}
return 0
}, func(l, r Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) bool {
return o1.Equals(l.F1, r.F1) && o2.Equals(l.F2, r.F2) && o3.Equals(l.F3, r.F3) && o4.Equals(l.F4, r.F4) && o5.Equals(l.F5, r.F5) && o6.Equals(l.F6, r.F6) && o7.Equals(l.F7, r.F7) && o8.Equals(l.F8, r.F8) && o9.Equals(l.F9, r.F9) && o10.Equals(l.F10, r.F10)
@@ -1559,60 +1306,29 @@ func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) MarshalJSON() ([]byte,
// UnmarshalJSON unmarshals a JSON array into a [Tuple10]
func (t *Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) UnmarshalJSON(data []byte) error {
var tmp []json.RawMessage
if err := json.Unmarshal(data, &tmp); err != nil {
return err
}
if err := json.Unmarshal(data, &tmp); err != nil {return err}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {return err}
if l > 1 {
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {
return err
}
if err := json.Unmarshal(tmp[1], &t.F2); err != nil {return err}
if l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {return err}
if l > 3 {
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {
return err
}
if err := json.Unmarshal(tmp[3], &t.F4); err != nil {return err}
if l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {return err}
if l > 5 {
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {
return err
}
if err := json.Unmarshal(tmp[5], &t.F6); err != nil {return err}
if l > 6 {
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
return err
}
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {return err}
if l > 7 {
if err := json.Unmarshal(tmp[7], &t.F8); err != nil {
return err
}
if err := json.Unmarshal(tmp[7], &t.F8); err != nil {return err}
if l > 8 {
if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
return err
}
if err := json.Unmarshal(tmp[8], &t.F9); err != nil {return err}
if l > 9 {
if err := json.Unmarshal(tmp[9], &t.F10); err != nil {
return err
}
}
}
}
}
}
}
}
}
}
}
if err := json.Unmarshal(tmp[9], &t.F10); err != nil {return err}
}}}}}}}}}}
return nil
}