the basics with generics

Signed-off-by: Aaron Schlesinger <[email protected]>

Author: arschles

bool.go

@@ -1,103 +1,11 @@
 package dcode
 
-import (
-	"fmt"
-	"reflect"
-)
-
 // Decode decodes b into i using d
-func Decode(b []byte, d Decoder, i interface{}) error {
-	ret, err := d.call(b)
+func Decode[T any](b []byte, d Decoder[T]) (T, error) {
+	var zero T
+	ret, err := d.Decode(b)
 	if err != nil {
-		return err
-	}
-	inputType := reflect.TypeOf(i)
-	if inputType.Kind() != reflect.Ptr {
-		return fmt.Errorf("Given %s type is not a pointer", inputType.Name())
-	}
-	inputTypeName := inputType.Elem().Name()
-	returnedType := reflect.TypeOf(ret)
-	if inputTypeName != returnedType.Name() {
-		return fmt.Errorf(
-			"Got type '%s', but expected '%s'",
-			returnedType.Name(),
-			inputType.Name(),
-		)
-	}
-	// Need to call Elem to traverse the pointer
-	inputVal := reflect.ValueOf(i).Elem()
-	retVal := reflect.ValueOf(ret)
-	if !inputVal.CanSet() {
-		return fmt.Errorf("Couldn't set the decoded value")
-	}
-	inputVal.Set(retVal)
-	return nil
-}
-
-// MapPair is a value to pass into the Map function. Create one
-// of these with the Pair function, and see the documentation
-// under the Map function for where this is used
-type MapPair struct {
-	decoder Decoder
-	iface   interface{}
-}
-
-// Pair returns a new MapPair
-func Pair(d Decoder, iface interface{}) MapPair {
-	return MapPair{decoder: d, iface: iface}
-}
-
-// Map decodes separate JSON fields into separate values,
-// using separate decoders, all from the same JSON.
-//
-// For example, if you have the following JSON:
-//
-//	json := `{"field1": 123, "field2": "456"}`
-//
-// And you have the following decoders:
-//
-//	dcode1 := Field("field1", Int())
-//	dcode2 := Field("field2", String())
-//
-// You can do the following:
-//
-//	stucco := struct{
-//		field1 int
-//		field2 string
-//	}
-//
-//	// check the error here!
-//	Map(
-//		[]byte(json),
-//		Pair(dcode1, &stucco.field1),
-//		Pair(dcode2, &stucco.field2),
-//	)
-//
-// Note: you can decode JSON into structs using this function,
-// but if you're trying to decode tons of fields from JSON
-// to struct fields, you might be better off using
-// encoding/json!
-func Map(
-	b []byte,
-	pairs ...MapPair,
-) error {
-	for _, pair := range pairs {
-		if err := Decode(b, pair.decoder, pair.iface); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// OneOf tries to decode b into i using every decoder in dList.
-//
-// It returns nil after the first decoder succeeds. If none
-// succeeded, returns an error
-func OneOf(b []byte, dList []Decoder, i interface{}) error {
-	for _, d := range dList {
-		if err := Decode(b, d, i); err == nil {
-			return nil
-		}
+		return zero, err
 	}
-	return fmt.Errorf("Tried %d decoders, none decoded", len(dList))
+	return ret, nil
 }

builder.go

@@ -8,10 +8,12 @@ package dcode
 // First(...).Then(...).Into(...).
 //
 // Check out the documentation for Field() or Builder for more information
-type Decoder struct {
-	call func([]byte) (interface{}, error)
+type Decoder[T any] interface {
+	Decode([]byte) (T, error)
 }
 
-func newDecoder(fn func([]byte) (interface{}, error)) Decoder {
-	return Decoder{call: fn}
+type DecoderFunc[T any] func([]byte) (T, error)
+
+func (d DecoderFunc[T]) Decode(b []byte) (T, error) {
+	return d(b)
 }

builder_test.go

@@ -3,37 +3,40 @@ package dcode
 import (
 	"fmt"
 	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
-func (t *TheSuite) TestSimpleInt() {
-	r := t.Require()
+func TestSimpleInt(t *testing.T) {
+	r := require.New(t)
 	ints := []int{1, 2, 3, 4, 5, 1000}
 	decoder := Int()
 	for i, expected := range ints {
 		expectedBytes := []byte(strconv.Itoa(expected))
-		actual, err := decoder.call(expectedBytes)
+		actual, err := decoder.Decode(expectedBytes)
 		r.NoError(err, "for iteration %d, int %d", i, expected)
 		r.Equal(expected, actual, "expected int %d", actual)
 	}
 
 	notInts := []string{`"abc"`, `"dev"`}
 	for _, notInt := range notInts {
-		actual, err := decoder.call([]byte(notInt))
+		actual, err := decoder.Decode([]byte(notInt))
 		r.True(err != nil)
 		r.Equal(0, actual)
 	}
 }
 
-func (t *TheSuite) TestSimpleString() {
-	r := t.Require()
+func TestSimpleString(t *testing.T) {
+	r := require.New(t)
 	decoder := String()
 	strings := []string{
 		`"this is a thing"`,
 		`"this is another thing"`,
 	}
 	for i, expected := range strings {
 		b := []byte(expected)
-		actual, err := decoder.call(b)
+		actual, err := decoder.Decode(b)
 		r.NoError(err, "for iteration %d", i)
 		actualJSONStr := fmt.Sprintf(`"%s"`, actual)
 		r.Equal(expected, actualJSONStr, "for iteration %d", i)

decode.go

@@ -0,0 +1,76 @@
+package dcode
+
+import (
+	"encoding/json"
+)
+
+// Float64 returns a Decoder that can decode JSON directly
+// into a float64
+func Float64() Decoder[float64] {
+	var ret float64
+	return DecoderFunc[float64](
+		func(b []byte) (float64, error) {
+			if err := json.Unmarshal(b, &ret); err != nil {
+				return ret, nil
+			}
+			return ret, nil
+		},
+	)
+}
+
+// Bool returns a decoder that can decode JSON
+// into a bool
+func Bool() Decoder[bool] {
+	return DecoderFunc[bool](func(b []byte) (bool, error) {
+		var ret bool
+		if err := json.Unmarshal(b, &ret); err != nil {
+			return false, err
+		}
+		return ret, nil
+	})
+}
+
+// Int returns a Decoder that can decode any JSON
+// into an integer
+func Int() Decoder[int] {
+	var zero int
+	return DecoderFunc[int](
+		func(b []byte) (int, error) {
+			var ret int
+			if err := json.Unmarshal(b, &ret); err != nil {
+				return zero, err
+			}
+			return ret, nil
+		},
+	)
+}
+
+type MapT map[string]interface{}
+
+func Map() Decoder[MapT] {
+	zero := map[string]interface{}{}
+	return DecoderFunc[MapT](
+		func(b []byte) (MapT, error) {
+			var ret map[string]interface{}
+			if err := json.Unmarshal(b, &ret); err != nil {
+				return zero, nil
+			}
+			return ret, nil
+		},
+	)
+}
+
+// String returns a Decoder that can decode JSON
+// into a string
+func String() Decoder[string] {
+	var zero string
+	return DecoderFunc[string](
+		func(b []byte) (string, error) {
+			var ret string
+			if err := json.Unmarshal(b, &ret); err != nil {
+				return zero, err
+			}
+			return ret, nil
+		},
+	)
+}