go/fp-go
1
0
Fork 0
mirror of https://github.com/IBM/fp-go.git synced 2025-08-10 22:31:32 +02:00
Code Issues Releases Activity

fix: optimize use of tuples

Browse Source 
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
2024-02-08 08:41:51 +01:00
parent 79652d8474
commit 9f6b6d4968
3 changed files with 658 additions and 1084 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
cli/tuple.go
View File

@@ -405,8 +405,6 @@ func generateTupleHelpers(filename string, count int) error {
fmt.Fprintf(f, `
import (
"fmt"
"encoding/json"
M "github.com/IBM/fp-go/monoid"
O "github.com/IBM/fp-go/ord"
)
@@ -457,7 +455,7 @@ func generateTupleMarshal(f *os.File, i int) {
fmt.Fprintf(f, "func (t ")
writeTupleType(f, "T", i)
fmt.Fprintf(f, ") MarshalJSON() ([]byte, error) {\n")
fmt.Fprintf(f, " return json.Marshal([]any{")
fmt.Fprintf(f, " return tupleMarshalJSON(")
// function prototypes
for j := 1; j <= i; j++ {
if j > 1 {
@@ -465,7 +463,7 @@ func generateTupleMarshal(f *os.File, i int) {
}
fmt.Fprintf(f, "t.F%d", j)
}
fmt.Fprintf(f, "})\n")
fmt.Fprintf(f, ")\n")
fmt.Fprintf(f, "}\n")
}
@@ -475,19 +473,12 @@ func generateTupleUnmarshal(f *os.File, i int) {
fmt.Fprintf(f, "func (t *")
writeTupleType(f, "T", i)
fmt.Fprintf(f, ") UnmarshalJSON(data []byte) error {\n")
fmt.Fprintf(f, " var tmp []json.RawMessage\n")
fmt.Fprintf(f, " if err := json.Unmarshal(data, &tmp); err != nil {return err}\n")
fmt.Fprintf(f, " l := len(tmp)\n")
// unmarshal fields
fmt.Fprintf(f, " return tupleUnmarshalJSON(data")
// function prototypes
for j := 1; j <= i; j++ {
fmt.Fprintf(f, " if l > %d {\n", j-1)
fmt.Fprintf(f, " if err := json.Unmarshal(tmp[%d], &t.F%d); err != nil {return err}\n", j-1, j)
fmt.Fprintf(f, ", &t.F%d", j)
}
fmt.Fprintf(f, " ")
for j := 1; j <= i; j++ {
fmt.Fprintf(f, "}")
}
fmt.Fprintf(f, "\n return nil\n")
fmt.Fprintf(f, ")\n")
fmt.Fprintf(f, "}\n")
}
@@ -570,30 +561,13 @@ func generateTupleString(f *os.File, i int) {
writeTupleType(f, "T", i)
fmt.Fprintf(f, ") String() string {\n")
// convert to string
fmt.Fprintf(f, " return fmt.Sprintf(\"Tuple%d[", i)
for j := 1; j <= i; j++ {
if j > 1 {
fmt.Fprintf(f, ", ")
}
fmt.Fprintf(f, "%s", "%T")
}
fmt.Fprintf(f, "](")
for j := 1; j <= i; j++ {
if j > 1 {
fmt.Fprintf(f, ", ")
}
fmt.Fprintf(f, "%s", "%v")
}
fmt.Fprintf(f, ")\", ")
fmt.Fprint(f, " return tupleString(")
for j := 1; j <= i; j++ {
if j > 1 {
fmt.Fprintf(f, ", ")
}
fmt.Fprintf(f, "t.F%d", j)
}
for j := 1; j <= i; j++ {
fmt.Fprintf(f, ", t.F%d", j)
}
fmt.Fprintf(f, ")\n")
fmt.Fprintf(f, "}\n")
}

610
tuple/gen.go
View File

@@ -1,12 +1,11 @@
// Code generated by go generate; DO NOT EDIT.
// This file was generated by robots at
// 2023-10-23 08:31:19.0449107 +0200 CEST m=+0.023307601
// 2024-02-08 08:36:32.8883679 +0100 CET m=+0.008054801
package tuple
import (
"encoding/json"
"fmt"
M "github.com/IBM/fp-go/monoid"
O "github.com/IBM/fp-go/ord"
)
@@ -137,9 +136,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)
@@ -162,27 +159,17 @@ func Replicate1[T any](t T) Tuple1[T] {
// String prints some debug info for the [Tuple1]
func (t Tuple1[T1]) String() string {
return fmt.Sprintf("Tuple1[%T](%v)", t.F1, t.F1)
return tupleString(t.F1)
}
// MarshalJSON marshals the [Tuple1] into a JSON array
func (t Tuple1[T1]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1})
return tupleMarshalJSON(t.F1)
}
// 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
}
l := len(tmp)
if l > 0 {
if err := json.Unmarshal(tmp[0], &t.F1); err != nil {
return err
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1)
}
// ToArray converts the [Tuple1] into an array of type [R] using 1 transformation functions from [T] to [R]
@@ -243,12 +230,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)
@@ -272,32 +255,17 @@ func Replicate2[T any](t T) Tuple2[T, T] {
// String prints some debug info for the [Tuple2]
func (t Tuple2[T1, T2]) String() string {
return fmt.Sprintf("Tuple2[%T, %T](%v, %v)", t.F1, t.F2, t.F1, t.F2)
return tupleString(t.F1, t.F2)
}
// MarshalJSON marshals the [Tuple2] into a JSON array
func (t Tuple2[T1, T2]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2})
return tupleMarshalJSON(t.F1, t.F2)
}
// 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
}
l := len(tmp)
if l > 0 {
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
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2)
}
// ToArray converts the [Tuple2] into an array of type [R] using 2 transformation functions from [T] to [R]
@@ -360,15 +328,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)
@@ -393,37 +355,17 @@ func Replicate3[T any](t T) Tuple3[T, T, T] {
// String prints some debug info for the [Tuple3]
func (t Tuple3[T1, T2, T3]) String() string {
return fmt.Sprintf("Tuple3[%T, %T, %T](%v, %v, %v)", t.F1, t.F2, t.F3, t.F1, t.F2, t.F3)
return tupleString(t.F1, t.F2, t.F3)
}
// MarshalJSON marshals the [Tuple3] into a JSON array
func (t Tuple3[T1, T2, T3]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3})
return tupleMarshalJSON(t.F1, t.F2, t.F3)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
if err := json.Unmarshal(tmp[2], &t.F3); err != nil {
return err
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3)
}
// ToArray converts the [Tuple3] into an array of type [R] using 3 transformation functions from [T] to [R]
@@ -488,18 +430,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)
@@ -525,42 +459,17 @@ func Replicate4[T any](t T) Tuple4[T, T, T, T] {
// String prints some debug info for the [Tuple4]
func (t Tuple4[T1, T2, T3, T4]) String() string {
return fmt.Sprintf("Tuple4[%T, %T, %T, %T](%v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F1, t.F2, t.F3, t.F4)
return tupleString(t.F1, t.F2, t.F3, t.F4)
}
// MarshalJSON marshals the [Tuple4] into a JSON array
func (t Tuple4[T1, T2, T3, T4]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4)
}
// ToArray converts the [Tuple4] into an array of type [R] using 4 transformation functions from [T] to [R]
@@ -627,21 +536,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)
@@ -668,47 +567,17 @@ func Replicate5[T any](t T) Tuple5[T, T, T, T, T] {
// String prints some debug info for the [Tuple5]
func (t Tuple5[T1, T2, T3, T4, T5]) String() string {
return fmt.Sprintf("Tuple5[%T, %T, %T, %T, %T](%v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F1, t.F2, t.F3, t.F4, t.F5)
return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5)
}
// MarshalJSON marshals the [Tuple5] into a JSON array
func (t Tuple5[T1, T2, T3, T4, T5]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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 l > 4 {
if err := json.Unmarshal(tmp[4], &t.F5); err != nil {
return err
}
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5)
}
// ToArray converts the [Tuple5] into an array of type [R] using 5 transformation functions from [T] to [R]
@@ -777,24 +646,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)
@@ -822,52 +679,17 @@ func Replicate6[T any](t T) Tuple6[T, T, T, T, T, T] {
// String prints some debug info for the [Tuple6]
func (t Tuple6[T1, T2, T3, T4, T5, T6]) String() string {
return fmt.Sprintf("Tuple6[%T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
}
// MarshalJSON marshals the [Tuple6] into a JSON array
func (t Tuple6[T1, T2, T3, T4, T5, T6]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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 l > 4 {
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
}
}
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6)
}
// ToArray converts the [Tuple6] into an array of type [R] using 6 transformation functions from [T] to [R]
@@ -938,27 +760,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)
@@ -987,57 +795,17 @@ func Replicate7[T any](t T) Tuple7[T, T, T, T, T, T, T] {
// String prints some debug info for the [Tuple7]
func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) String() string {
return fmt.Sprintf("Tuple7[%T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
}
// MarshalJSON marshals the [Tuple7] into a JSON array
func (t Tuple7[T1, T2, T3, T4, T5, T6, T7]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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 l > 4 {
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 l > 6 {
if err := json.Unmarshal(tmp[6], &t.F7); err != nil {
return err
}
}
}
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7)
}
// ToArray converts the [Tuple7] into an array of type [R] using 7 transformation functions from [T] to [R]
@@ -1110,30 +878,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)
@@ -1163,62 +915,17 @@ func Replicate8[T any](t T) Tuple8[T, T, T, T, T, T, T, T] {
// String prints some debug info for the [Tuple8]
func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) String() string {
return fmt.Sprintf("Tuple8[%T, %T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
}
// MarshalJSON marshals the [Tuple8] into a JSON array
func (t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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 l > 4 {
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 l > 6 {
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
}
}
}
}
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8)
}
// ToArray converts the [Tuple8] into an array of type [R] using 8 transformation functions from [T] to [R]
@@ -1293,33 +1000,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)
@@ -1350,67 +1039,17 @@ func Replicate9[T any](t T) Tuple9[T, T, T, T, T, T, T, T, T] {
// String prints some debug info for the [Tuple9]
func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) String() string {
return fmt.Sprintf("Tuple9[%T, %T, %T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
}
// MarshalJSON marshals the [Tuple9] into a JSON array
func (t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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 l > 4 {
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 l > 6 {
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 l > 8 {
if err := json.Unmarshal(tmp[8], &t.F9); err != nil {
return err
}
}
}
}
}
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9)
}
// ToArray converts the [Tuple9] into an array of type [R] using 9 transformation functions from [T] to [R]
@@ -1487,36 +1126,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)
@@ -1548,72 +1167,17 @@ func Replicate10[T any](t T) Tuple10[T, T, T, T, T, T, T, T, T, T] {
// String prints some debug info for the [Tuple10]
func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) String() string {
return fmt.Sprintf("Tuple10[%T, %T, %T, %T, %T, %T, %T, %T, %T, %T](%v, %v, %v, %v, %v, %v, %v, %v, %v, %v)", t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10, t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
return tupleString(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
}
// MarshalJSON marshals the [Tuple10] into a JSON array
func (t Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) MarshalJSON() ([]byte, error) {
return json.Marshal([]any{t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10})
return tupleMarshalJSON(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, t.F10)
}
// 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
}
l := len(tmp)
if l > 0 {
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 l > 2 {
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 l > 4 {
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 l > 6 {
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 l > 8 {
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
}
}
}
}
}
}
}
}
}
}
}
return nil
return tupleUnmarshalJSON(data, &t.F1, &t.F2, &t.F3, &t.F4, &t.F5, &t.F6, &t.F7, &t.F8, &t.F9, &t.F10)
}
// ToArray converts the [Tuple10] into an array of type [R] using 10 transformation functions from [T] to [R]

36
tuple/tuple.go
View File

@@ -17,6 +17,14 @@
// consider to use arrays for simplicity
package tuple
import (
"encoding/json"
"fmt"
"strings"
N "github.com/IBM/fp-go/number"
)
func Of[T1 any](t T1) Tuple1[T1] {
return MakeTuple1(t)
}
@@ -46,3 +54,31 @@ func BiMap[E, G, A, B any](mapSnd func(E) G, mapFst func(A) B) func(Tuple2[A, E]
return MakeTuple2(mapFst(First(t)), mapSnd(Second(t)))
}
}
// marshalJSON marshals the tuple into a JSON array
func tupleMarshalJSON(src ...any) ([]byte, error) {
return json.Marshal(src)
}
// tupleUnmarshalJSON unmarshals a JSON array into a tuple
func tupleUnmarshalJSON(data []byte, dst ...any) error {
var src []json.RawMessage
if err := json.Unmarshal(data, &src); err != nil {
return err
}
l := N.Min(len(src), len(dst))
// unmarshal
for i := 0; i < l; i++ {
if err := json.Unmarshal(src[i], dst[i]); err != nil {
return err
}
}
// successfully decoded the tuple
return nil
}
// tupleString converts a tuple to a string
func tupleString(src ...any) string {
l := len(src)
return fmt.Sprintf("Tuple%d[%s](%s)", l, fmt.Sprintf(strings.Repeat(", %T", l)[2:], src...), fmt.Sprintf(strings.Repeat(", %v", l)[2:], src...))
}