Fix JSON unmarshalling in complex structures bug (#22)

* Add documentation in README about JSON marshalling

Author: barweiss

README.md

@@ -4,7 +4,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/barweiss/go-tuple/badge.svg)](https://coveralls.io/github/barweiss/go-tuple)
 [![Go Report Card](https://goreportcard.com/badge/github.com/barweiss/go-tuple)](https://goreportcard.com/report/github.com/barweiss/go-tuple)
 [![Go Reference](https://pkg.go.dev/badge/github.com/barweiss/go-tuple.svg)](https://pkg.go.dev/github.com/barweiss/go-tuple)
-[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)  
+[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
 
 Go 1.18+ tuple implementation.
 
@@ -79,6 +79,35 @@ tup := tuple.New2(5, "hi!")
 a, b := tup.Values()
 ```
 
+## JSON Marshalling
+
+Tuples are marshalled and unmarshalled as JSON arrays.
+
+```go
+type User struct {
+	Name string `json:"name"`
+	Age  int    `json:"age,omitempty"`
+}
+
+type MyJSON struct {
+	Users []tuple.T2[string, User] `json:"users"`
+}
+
+func main() {
+	data := MyJSON{
+		Users: []tuple.T2[string, User]{
+			tuple.New2("foo", User{Name: "foo", Age: 42}),
+			tuple.New2("bar", User{Name: "bar", Age: 21}),
+			tuple.New2("baz", User{Name: "baz"}),
+		},
+	}
+
+	marshalled, _ := json.Marshal(data)
+	fmt.Printf("%s\n", string(marshalled))
+	// Outputs: {"users":[["foo",{"name":"foo","age":42}],["bar",{"name":"bar","age":21}],["baz",{"name":"baz"}]]}
+}
+```
+
 ## Comparison
 
 Tuples are compared from the first element to the last.
@@ -101,6 +130,7 @@ fmt.Println(tups) // [["bar", -4, 43], ["foo", 2, -23], ["foo", 72, 15]].
 ```
 
 ---
+
 **NOTE**
 
 In order to compare tuples, all tuple elements must match `constraints.Ordered`.
@@ -165,7 +195,7 @@ func main() {
 }
 ```
 
-In order to call the complex types variation of the comparable functions, __all__ tuple types must match the `Comparable` constraint.
+In order to call the complex types variation of the comparable functions, **all** tuple types must match the `Comparable` constraint.
 
 While this is not ideal, this a known inconvenience given the current type parameters capabilities in Go.
 Some solutions have been porposed for this issue ([lesser](https://github.com/lelysses/lesser), for example, beatifully articulates the issue),

scripts/gen/tuple.tpl

@@ -239,16 +239,21 @@ func (t {{$typeRef}}) MarshalJSON() ([]byte, error) {
 
 // MarshalJSON unmarshals the tuple from a JSON array.
 func (t *{{$typeRef}}) UnmarshalJSON(data []byte) error {
-	var slice []any
+	// Working with json.RawMessage instead of any enables custom struct support.
+	var slice []json.RawMessage
 	if err := json.Unmarshal(data, &slice); err != nil {
-		return err
+		return fmt.Errorf("unable to unmarshal json array for tuple: %w", err)
 	}
 
-	unmarshalled, err := FromSlice{{.Len}}[{{.GenericTypesForward}}](slice)
-	if err != nil {
-		return err
+	if len(slice) != {{.Len}} {
+		return fmt.Errorf("unmarshalled json array length %d must match number of tuple values {{.Len}}", len(slice))
 	}
 
-	*t = unmarshalled
+	{{- range $index, $num := .Indexes}}
+	if err := json.Unmarshal(slice[{{$index}}], &t.V{{.}}); err != nil {
+		return fmt.Errorf("value %q at slice index {{$index}} failed to unmarshal: %w", string(slice[{{$index}}]), err)
+	}
+	{{end -}}
+
 	return nil
 }

scripts/gen/tuple_test.tpl

@@ -515,15 +515,10 @@ func TestT{{.Len}}_UnmarshalJSON(t *testing.T) {
 			data: []byte(`["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]`),
 			wantErr: true,
 		},
+		{{range $invalidIndex, $_ := .Indexes}}
 		{
-			name: "json array of invalid types",
-			data: []byte(`[{{range $.Indexes}}{{if ne . 1}},{{end}}{{.}}{{end}}]`),
-			wantErr: true,
-		},
-		{{if gt .Len 1 -}}
-		{
-			name: "json array with 1 invalid type",
-			data: []byte(`[{{range $.Indexes}}{{if ne . 1}},{{end}}{{if eq . 1}}{{.}}{{else}}{{. | quote}}{{end}}{{end}}]`),
+			name: "json array with invalid type at index {{$invalidIndex}}",
+			data: []byte(`[{{range $currentIndex, $num := $.Indexes}}{{if ne $currentIndex 0}},{{end}}{{if eq $currentIndex $invalidIndex}}{{$num}}{{else}}{{$num | quote}}{{end}}{{end}}]`),
 			wantErr: true,
 		},
 		{{- end}}
@@ -555,6 +550,25 @@ func TestT{{.Len}}_UnmarshalJSON(t *testing.T) {
 	}
 }
 
+func TestT{{.Len}}_Unmarshal_CustomStruct(t *testing.T) {
+	type Custom struct {
+		Name string `json:"name"`
+		Age int `json:"age"`
+	}
+
+	want := New{{.Len}}({{range .Indexes}}Custom{ Name: {{. | quote}}, Age: {{.}} },{{end}})
+	var got T{{.Len}}[{{range .Indexes}}Custom,{{end}}]
+	err := json.Unmarshal([]byte(`[
+		{{- range .Indexes -}}
+		{{- if ne . 1}},{{end}}
+		{ "name": {{. | quote}}, "age": {{.}} }
+		{{- end}}
+	]`), &got)
+
+	require.NoError(t, err)
+	require.Equal(t, want, got)
+}
+
 func TestT{{.Len}}_Marshal_Unmarshal(t *testing.T) {
 	tup := New{{.Len}}({{range .Indexes}}{{. | quote}},{{end}})
 

tuple1.go

@@ -204,16 +204,17 @@ func (t T1[Ty1]) MarshalJSON() ([]byte, error) {
 
 // MarshalJSON unmarshals the tuple from a JSON array.
 func (t *T1[Ty1]) UnmarshalJSON(data []byte) error {
-	var slice []any
+	// Working with json.RawMessage instead of any enables custom struct support.
+	var slice []json.RawMessage
 	if err := json.Unmarshal(data, &slice); err != nil {
-		return err
+		return fmt.Errorf("unable to unmarshal json array for tuple: %w", err)
 	}
 
-	unmarshalled, err := FromSlice1[Ty1](slice)
-	if err != nil {
-		return err
+	if len(slice) != 1 {
+		return fmt.Errorf("unmarshalled json array length %d must match number of tuple values 1", len(slice))
+	}
+	if err := json.Unmarshal(slice[0], &t.V1); err != nil {
+		return fmt.Errorf("value %q at slice index 0 failed to unmarshal: %w", string(slice[0]), err)
 	}
-
-	*t = unmarshalled
 	return nil
 }

tuple1_test.go

@@ -461,12 +461,12 @@ func TestT1_UnmarshalJSON(t *testing.T) {
 			data:    []byte(`["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]`),
 			wantErr: true,
 		},
+
 		{
-			name:    "json array of invalid types",
+			name:    "json array with invalid type at index 0",
 			data:    []byte(`[1]`),
 			wantErr: true,
 		},
-
 		{
 			name:    "json array of valid types",
 			data:    []byte(`["1"]`),
@@ -495,6 +495,22 @@ func TestT1_UnmarshalJSON(t *testing.T) {
 	}
 }
 
+func TestT1_Unmarshal_CustomStruct(t *testing.T) {
+	type Custom struct {
+		Name string `json:"name"`
+		Age  int    `json:"age"`
+	}
+
+	want := New1(Custom{Name: "1", Age: 1})
+	var got T1[Custom]
+	err := json.Unmarshal([]byte(`[
+		{ "name": "1", "age": 1 }
+	]`), &got)
+
+	require.NoError(t, err)
+	require.Equal(t, want, got)
+}
+
 func TestT1_Marshal_Unmarshal(t *testing.T) {
 	tup := New1("1")
 

tuple2.go

@@ -220,16 +220,21 @@ func (t T2[Ty1, Ty2]) MarshalJSON() ([]byte, error) {
 
 // MarshalJSON unmarshals the tuple from a JSON array.
 func (t *T2[Ty1, Ty2]) UnmarshalJSON(data []byte) error {
-	var slice []any
+	// Working with json.RawMessage instead of any enables custom struct support.
+	var slice []json.RawMessage
 	if err := json.Unmarshal(data, &slice); err != nil {
-		return err
+		return fmt.Errorf("unable to unmarshal json array for tuple: %w", err)
 	}
 
-	unmarshalled, err := FromSlice2[Ty1, Ty2](slice)
-	if err != nil {
-		return err
+	if len(slice) != 2 {
+		return fmt.Errorf("unmarshalled json array length %d must match number of tuple values 2", len(slice))
+	}
+	if err := json.Unmarshal(slice[0], &t.V1); err != nil {
+		return fmt.Errorf("value %q at slice index 0 failed to unmarshal: %w", string(slice[0]), err)
 	}
 
-	*t = unmarshalled
+	if err := json.Unmarshal(slice[1], &t.V2); err != nil {
+		return fmt.Errorf("value %q at slice index 1 failed to unmarshal: %w", string(slice[1]), err)
+	}
 	return nil
 }

tuple2_test.go

@@ -487,14 +487,15 @@ func TestT2_UnmarshalJSON(t *testing.T) {
 			data:    []byte(`["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]`),
 			wantErr: true,
 		},
+
 		{
-			name:    "json array of invalid types",
-			data:    []byte(`[1,2]`),
+			name:    "json array with invalid type at index 0",
+			data:    []byte(`[1,"2"]`),
 			wantErr: true,
 		},
 		{
-			name:    "json array with 1 invalid type",
-			data:    []byte(`[1,"2"]`),
+			name:    "json array with invalid type at index 1",
+			data:    []byte(`["1",2]`),
 			wantErr: true,
 		},
 		{
@@ -525,6 +526,23 @@ func TestT2_UnmarshalJSON(t *testing.T) {
 	}
 }
 
+func TestT2_Unmarshal_CustomStruct(t *testing.T) {
+	type Custom struct {
+		Name string `json:"name"`
+		Age  int    `json:"age"`
+	}
+
+	want := New2(Custom{Name: "1", Age: 1}, Custom{Name: "2", Age: 2})
+	var got T2[Custom, Custom]
+	err := json.Unmarshal([]byte(`[
+		{ "name": "1", "age": 1 },
+		{ "name": "2", "age": 2 }
+	]`), &got)
+
+	require.NoError(t, err)
+	require.Equal(t, want, got)
+}
+
 func TestT2_Marshal_Unmarshal(t *testing.T) {
 	tup := New2("1", "2")
 

tuple3.go

@@ -236,16 +236,25 @@ func (t T3[Ty1, Ty2, Ty3]) MarshalJSON() ([]byte, error) {
 
 // MarshalJSON unmarshals the tuple from a JSON array.
 func (t *T3[Ty1, Ty2, Ty3]) UnmarshalJSON(data []byte) error {
-	var slice []any
+	// Working with json.RawMessage instead of any enables custom struct support.
+	var slice []json.RawMessage
 	if err := json.Unmarshal(data, &slice); err != nil {
-		return err
+		return fmt.Errorf("unable to unmarshal json array for tuple: %w", err)
 	}
 
-	unmarshalled, err := FromSlice3[Ty1, Ty2, Ty3](slice)
-	if err != nil {
-		return err
+	if len(slice) != 3 {
+		return fmt.Errorf("unmarshalled json array length %d must match number of tuple values 3", len(slice))
+	}
+	if err := json.Unmarshal(slice[0], &t.V1); err != nil {
+		return fmt.Errorf("value %q at slice index 0 failed to unmarshal: %w", string(slice[0]), err)
+	}
+
+	if err := json.Unmarshal(slice[1], &t.V2); err != nil {
+		return fmt.Errorf("value %q at slice index 1 failed to unmarshal: %w", string(slice[1]), err)
 	}
 
-	*t = unmarshalled
+	if err := json.Unmarshal(slice[2], &t.V3); err != nil {
+		return fmt.Errorf("value %q at slice index 2 failed to unmarshal: %w", string(slice[2]), err)
+	}
 	return nil
 }

tuple3_test.go

@@ -517,14 +517,20 @@ func TestT3_UnmarshalJSON(t *testing.T) {
 			data:    []byte(`["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]`),
 			wantErr: true,
 		},
+
 		{
-			name:    "json array of invalid types",
-			data:    []byte(`[1,2,3]`),
+			name:    "json array with invalid type at index 0",
+			data:    []byte(`[1,"2","3"]`),
 			wantErr: true,
 		},
 		{
-			name:    "json array with 1 invalid type",
-			data:    []byte(`[1,"2","3"]`),
+			name:    "json array with invalid type at index 1",
+			data:    []byte(`["1",2,"3"]`),
+			wantErr: true,
+		},
+		{
+			name:    "json array with invalid type at index 2",
+			data:    []byte(`["1","2",3]`),
 			wantErr: true,
 		},
 		{
@@ -555,6 +561,24 @@ func TestT3_UnmarshalJSON(t *testing.T) {
 	}
 }
 
+func TestT3_Unmarshal_CustomStruct(t *testing.T) {
+	type Custom struct {
+		Name string `json:"name"`
+		Age  int    `json:"age"`
+	}
+
+	want := New3(Custom{Name: "1", Age: 1}, Custom{Name: "2", Age: 2}, Custom{Name: "3", Age: 3})
+	var got T3[Custom, Custom, Custom]
+	err := json.Unmarshal([]byte(`[
+		{ "name": "1", "age": 1 },
+		{ "name": "2", "age": 2 },
+		{ "name": "3", "age": 3 }
+	]`), &got)
+
+	require.NoError(t, err)
+	require.Equal(t, want, got)
+}
+
 func TestT3_Marshal_Unmarshal(t *testing.T) {
 	tup := New3("1", "2", "3")
 

tuple4.go

@@ -252,16 +252,29 @@ func (t T4[Ty1, Ty2, Ty3, Ty4]) MarshalJSON() ([]byte, error) {
 
 // MarshalJSON unmarshals the tuple from a JSON array.
 func (t *T4[Ty1, Ty2, Ty3, Ty4]) UnmarshalJSON(data []byte) error {
-	var slice []any
+	// Working with json.RawMessage instead of any enables custom struct support.
+	var slice []json.RawMessage
 	if err := json.Unmarshal(data, &slice); err != nil {
-		return err
+		return fmt.Errorf("unable to unmarshal json array for tuple: %w", err)
 	}
 
-	unmarshalled, err := FromSlice4[Ty1, Ty2, Ty3, Ty4](slice)
-	if err != nil {
-		return err
+	if len(slice) != 4 {
+		return fmt.Errorf("unmarshalled json array length %d must match number of tuple values 4", len(slice))
+	}
+	if err := json.Unmarshal(slice[0], &t.V1); err != nil {
+		return fmt.Errorf("value %q at slice index 0 failed to unmarshal: %w", string(slice[0]), err)
+	}
+
+	if err := json.Unmarshal(slice[1], &t.V2); err != nil {
+		return fmt.Errorf("value %q at slice index 1 failed to unmarshal: %w", string(slice[1]), err)
 	}
 
-	*t = unmarshalled
+	if err := json.Unmarshal(slice[2], &t.V3); err != nil {
+		return fmt.Errorf("value %q at slice index 2 failed to unmarshal: %w", string(slice[2]), err)
+	}
+
+	if err := json.Unmarshal(slice[3], &t.V4); err != nil {
+		return fmt.Errorf("value %q at slice index 3 failed to unmarshal: %w", string(slice[3]), err)
+	}
 	return nil
 }